I'm a senior at the University of Hartford studying Electrical Engineering and Computer Science. I'll be graduating in May of 2020 with two Bachelor Degrees.
In Electrical Engineering, I have spent my academic career focusing on Communications Engineering, Controls Engineering, and Networking. I also have a solid base in circuit and electronic design, electromagnetic field theory, and microprocessing applications.
In my Computer Science courses, I have focused on Software Engineering and Development, Database Management and Design, and Web Development.
(413) 455 - 7181 |<EMAIL_ADDRESS>| 118 North Lane, Granville, MA


|
Assimp
5.0.1, master @ cd42b955
|
Class to parse ASE files. More...
Public Member Functions | |
| Parser (const char *szFile, unsigned int fileFormatDefault) | |
| Construct a parser from a given input file which is guaranteed to be terminated with zero. More... | |
| void | Parse () |
| Parses the file into the parsers internal representation. More... | |
Public Attributes | |
| bool | bLastWasEndLine |
| true if the last character read was an end-line character More... | |
| const char * | filePtr |
| Pointer to current data. More... | |
| unsigned int | iFileFormat |
| File format version. More... | |
| unsigned int | iFirstFrame |
| First frame. More... | |
| unsigned int | iFrameSpeed |
| Frame speed - frames per second. More... | |
| unsigned int | iLastFrame |
| Last frame. More... | |
| unsigned int | iLineNumber |
| Current line in the file. More... | |
| unsigned int | iTicksPerFrame |
| Ticks per frame. More... | |
| aiColor3D | m_clrAmbient |
| Base ambient color to be passed to all materials QNAN if none was found. More... | |
| aiColor3D | m_clrBackground |
| background color to be passed to the viewer QNAN if none was found More... | |
| std::vector< Camera > | m_vCameras |
| List of all cameras found in the file. More... | |
| std::vector< Dummy > | m_vDummies |
| List of all dummies found in the file. More... | |
| std::vector< Light > | m_vLights |
| List of all lights found in the file. More... | |
| std::vector< Material > | m_vMaterials |
| List of all materials found in the file. More... | |
| std::vector< Mesh > | m_vMeshes |
| List of all meshes found in the file. More... | |
Private Member Functions | |
| Parser () AI_NO_EXCEPT | |
| AI_WONT_RETURN void | LogError (const char *szWarn) AI_WONT_RETURN_SUFFIX |
| Output an error to the logger. More... | |
| void | LogInfo (const char *szWarn) |
| Output a message to the logger. More... | |
| void | LogWarning (const char *szWarn) |
| Output a warning to the logger. More... | |
| void | ParseLV1MaterialListBlock () |
| Parse the *MATERIAL_LIST block in a file. More... | |
| void | ParseLV1ObjectBlock (BaseNode &mesh) |
| Parse a *<xxx>OBJECT block in a file. More... | |
| void | ParseLV1SceneBlock () |
| Parse the *SCENE block in a file. More... | |
| void | ParseLV1SoftSkinBlock () |
| Parse the *MESH_SOFTSKINVERTS block in a file. More... | |
| void | ParseLV2AnimationBlock (BaseNode &mesh) |
| Parse a *TM_ANIMATION block in a file. More... | |
| void | ParseLV2CameraSettingsBlock (Camera &cam) |
| Parse a *CAMERA_SETTINGS block in a file. More... | |
| void | ParseLV2LightSettingsBlock (Light &light) |
| Parse a *LIGHT_SETTINGS block in a file. More... | |
| void | ParseLV2MaterialBlock (Material &mat) |
| Parse a *MATERIAL blocks in a material list. More... | |
| void | ParseLV2MeshBlock (Mesh &mesh) |
| Parse a *MESH block in a file. More... | |
| void | ParseLV2NodeTransformBlock (BaseNode &mesh) |
| Parse a *NODE_TM block in a file. More... | |
| void | ParseLV3MapBlock (Texture &map) |
| Parse the *MAP_XXXXXX blocks in a material. More... | |
| void | ParseLV3MappingChannel (unsigned int iChannel, Mesh &mesh) |
| Parse an additional mapping channel (specified via *MESH_MAPPINGCHANNEL) More... | |
| void | ParseLV3MeshCFaceListBlock (unsigned int iNumFaces, Mesh &mesh) |
| Parse a *MESH_CFACELIST block in a file. More... | |
| void | ParseLV3MeshCListBlock (unsigned int iNumVertices, Mesh &mesh) |
| Parse a *MESH_CVERTLIST block in a file. More... | |
| void | ParseLV3MeshFaceListBlock (unsigned int iNumFaces, Mesh &mesh) |
| Parse a *MESH_FACE_LIST block in a file. More... | |
| void | ParseLV3MeshNormalListBlock (Mesh &mesh) |
| Parse a *MESH_NORMALS block in a file. More... | |
| void | ParseLV3MeshTFaceListBlock (unsigned int iNumFaces, Mesh &mesh, unsigned int iChannel=0) |
| Parse a *MESH_TFACELIST block in a file. More... | |
| void | ParseLV3MeshTListBlock (unsigned int iNumVertices, Mesh &mesh, unsigned int iChannel=0) |
| Parse a *MESH_TVERT_LIST block in a file. More... | |
| void | ParseLV3MeshVertexListBlock (unsigned int iNumVertices, Mesh &mesh) |
| Parse a *MESH_VERTEX_LIST block in a file. More... | |
| void | ParseLV3MeshWeightsBlock (Mesh &mesh) |
| Parse a *MESH_WEIGHTSblock in a file. More... | |
| void | ParseLV3PosAnimationBlock (ASE::Animation &anim) |
| void | ParseLV3RotAnimationBlock (ASE::Animation &anim) |
| void | ParseLV3ScaleAnimationBlock (ASE::Animation &anim) |
| void | ParseLV4MeshBones (unsigned int iNumBones, Mesh &mesh) |
| Parse the bone list of a file. More... | |
| void | ParseLV4MeshBonesVertices (unsigned int iNumVertices, Mesh &mesh) |
| Parse the bone vertices list of a file. More... | |
| void | ParseLV4MeshFace (ASE::Face &out) |
| Parse a *MESH_FACE block in a file. More... | |
| void | ParseLV4MeshFloat (ai_real &fOut) |
| Parse a single float element. More... | |
| void | ParseLV4MeshFloatTriple (ai_real *apOut) |
| Parse a *MESH_VERT block in a file (also works for MESH_TVERT, MESH_CFACE, MESH_VERTCOL ...) More... | |
| void | ParseLV4MeshFloatTriple (ai_real *apOut, unsigned int &rIndexOut) |
| Parse a *MESH_VERT block in a file (also works for MESH_TVERT, MESH_CFACE, MESH_VERTCOL ...) More... | |
| void | ParseLV4MeshLong (unsigned int &iOut) |
| Parse a single int element. More... | |
| void | ParseLV4MeshLongTriple (unsigned int *apOut) |
| Parse a *MESH_TFACE block in a file (also works for MESH_CFACE) More... | |
| void | ParseLV4MeshLongTriple (unsigned int *apOut, unsigned int &rIndexOut) |
| Parse a *MESH_TFACE block in a file (also works for MESH_CFACE) More... | |
| bool | ParseString (std::string &out, const char *szName) |
| Parse a string, enclosed in double quotation marks. More... | |
| bool | SkipSection () |
| Skip the current section until the token after the closing }. More... | |
| bool | SkipToNextToken () |
| Skip everything to the next: '*' or '\0'. More... | |
Class to parse ASE files.
|
inlineprivate |
| Parser::Parser | ( | const char * | szFile, |
| unsigned int | fileFormatDefault | ||
| ) |
Construct a parser from a given input file which is guaranteed to be terminated with zero.
| szFile | Input file |
| fileFormatDefault | Assumed file format version. If the file format is specified in the file the new value replaces the default value. |
|
private |
Output an error to the logger.
| szWarn | Error message |
|
private |
Output a message to the logger.
| szWarn | Message |
|
private |
Output a warning to the logger.
| szWarn | Warn message |
| void Parser::Parse | ( | ) |
Parses the file into the parsers internal representation.
|
private |
Parse the *MATERIAL_LIST block in a file.
|
private |
Parse a *<xxx>OBJECT block in a file.
| mesh | Node to be filled |
|
private |
Parse the *SCENE block in a file.
|
private |
Parse the *MESH_SOFTSKINVERTS block in a file.
FORMAT BEGIN
MESH_SOFTSKINVERTS { <nodename> <number of vertices>
[for <number of vertices> times:] <number of weights> [for <number of weights> times:] <bone name> <weight> }
FORMAT END
|
private |
Parse a *TM_ANIMATION block in a file.
| mesh | Mesh object to be filled |
|
private |
Parse a *CAMERA_SETTINGS block in a file.
| cam | Camera object to be filled |
|
private |
Parse a *LIGHT_SETTINGS block in a file.
| light | Light object to be filled |
|
private |
Parse a *MATERIAL blocks in a material list.
| mat | Material structure to be filled |
|
private |
Parse a *MESH block in a file.
| mesh | Mesh object to be filled |
|
private |
Parse a *NODE_TM block in a file.
| mesh | Node (!) object to be filled |
|
private |
Parse the *MAP_XXXXXX blocks in a material.
| map | Texture structure to be filled |
|
private |
Parse an additional mapping channel (specified via *MESH_MAPPINGCHANNEL)
| iChannel | Channel index to be filled |
| mesh | Mesh object to be filled |
|
private |
Parse a *MESH_CFACELIST block in a file.
| iNumFaces | Value of *MESH_NUMCVFACES, if present. Otherwise zero. This is used to check the consistency of the file. A warning is sent to the logger if the validations fails. |
| mesh | Mesh object to be filled |
|
private |
Parse a *MESH_CVERTLIST block in a file.
| iNumVertices | Value of *MESH_NUMCVERTEX, if present. Otherwise zero. This is used to check the consistency of the file. A warning is sent to the logger if the validations fails. |
| mesh | Mesh object to be filled |
|
private |
Parse a *MESH_FACE_LIST block in a file.
| iNumFaces | Value of *MESH_NUMFACES, if present. Otherwise zero. This is used to check the consistency of the file. A warning is sent to the logger if the validations fails. |
| mesh | Mesh object to be filled |
|
private |
Parse a *MESH_NORMALS block in a file.
| mesh | Mesh object to be filled |
|
private |
Parse a *MESH_TFACELIST block in a file.
| iNumFaces | Value of *MESH_NUMTVFACES, if present. Otherwise zero. This is used to check the consistency of the file. A warning is sent to the logger if the validations fails. |
| mesh | Mesh object to be filled |
| iChannel | Output UVW channel |
|
private |
Parse a *MESH_TVERT_LIST block in a file.
| iNumVertices | Value of *MESH_NUMTVERTEX, if present. Otherwise zero. This is used to check the consistency of the file. A warning is sent to the logger if the validations fails. |
| mesh | Mesh object to be filled |
| iChannel | Output UVW channel |
|
private |
Parse a *MESH_VERTEX_LIST block in a file.
| iNumVertices | Value of *MESH_NUMVERTEX, if present. Otherwise zero. This is used to check the consistency of the file. A warning is sent to the logger if the validations fails. |
| mesh | Mesh object to be filled |
|
private |
Parse a *MESH_WEIGHTSblock in a file.
| mesh | Mesh object to be filled |
|
private |
|
private |
|
private |
|
private |
Parse the bone list of a file.
| mesh | Mesh object to be filled |
| iNumBones | Number of bones in the mesh |
|
private |
Parse the bone vertices list of a file.
| mesh | Mesh object to be filled |
| iNumVertices | Number of vertices to be parsed |
|
private |
Parse a *MESH_FACE block in a file.
| out | receive the face data |
|
private |
Parse a single float element.
| fOut | Output float |
|
private |
Parse a *MESH_VERT block in a file (also works for MESH_TVERT, MESH_CFACE, MESH_VERTCOL ...)
| apOut | Output buffer (3 floats) |
|
private |
Parse a *MESH_VERT block in a file (also works for MESH_TVERT, MESH_CFACE, MESH_VERTCOL ...)
| apOut | Output buffer (3 floats) |
| rIndexOut | Output index |
|
private |
Parse a single int element.
| iOut | Output integer |
|
private |
Parse a *MESH_TFACE block in a file (also works for MESH_CFACE)
| apOut | Output buffer (3 ints) |
|
private |
Parse a *MESH_TFACE block in a file (also works for MESH_CFACE)
| apOut | Output buffer (3 ints) |
| rIndexOut | Output index |
|
private |
Parse a string, enclosed in double quotation marks.
| out | Output string |
| szName | Name of the enclosing element -> used in error messages. |
|
private |
Skip the current section until the token after the closing }.
This function handles embedded subsections correctly
|
private |
Skip everything to the next: '*' or '\0'.
| bool Assimp::ASE::Parser::bLastWasEndLine |
true if the last character read was an end-line character
| const char* Assimp::ASE::Parser::filePtr |
Pointer to current data.
| unsigned int Assimp::ASE::Parser::iFileFormat |
File format version.
| unsigned int Assimp::ASE::Parser::iFirstFrame |
First frame.
| unsigned int Assimp::ASE::Parser::iFrameSpeed |
Frame speed - frames per second.
| unsigned int Assimp::ASE::Parser::iLastFrame |
Last frame.
| unsigned int Assimp::ASE::Parser::iLineNumber |
Current line in the file.
| unsigned int Assimp::ASE::Parser::iTicksPerFrame |
Ticks per frame.
| aiColor3D Assimp::ASE::Parser::m_clrAmbient |
Base ambient color to be passed to all materials QNAN if none was found.
| aiColor3D Assimp::ASE::Parser::m_clrBackground |
background color to be passed to the viewer QNAN if none was found
| std::vector<Camera> Assimp::ASE::Parser::m_vCameras |
List of all cameras found in the file.
| std::vector<Dummy> Assimp::ASE::Parser::m_vDummies |
List of all dummies found in the file.
| std::vector<Light> Assimp::ASE::Parser::m_vLights |
List of all lights found in the file.
| std::vector<Material> Assimp::ASE::Parser::m_vMaterials |
List of all materials found in the file.
| std::vector<Mesh> Assimp::ASE::Parser::m_vMeshes |
List of all meshes found in the file.


{% load staticfiles i18n %}
Welcome, {{ user.username }}
Use this document as a way to quick start any new project.


Modified version of SimpleCAT.
More...
#include <Ecat_KistSensor.h>
|
| enum | ModeOfOperation {
MODE_NO_MODE = 0,
MODE_PROFILED_POSITION = 1,
MODE_PROFILED_VELOCITY = 3,
MODE_PROFILED_TORQUE = 4,
MODE_HOMING = 6,
MODE_INTERPOLATED_POSITION = 7,
MODE_CYCLIC_SYNC_POSITION = 8,
MODE_CYCLIC_SYNC_VELEOCITY = 9,
MODE_CYCLIC_SYNC_TORQUE = 10
} |
| | Description of Mode of Operation(Predefined in terms of CiA402 Profile)
|
| |
|
typedef std::map< unsigned int, std::vector< unsigned int > > | DomainMap |
| | base member for PDO domain
|
| |
|
| bool | initialized () const |
| | Check the Elmo is Initialized. More...
|
| |
| int | Elmo_DeviceState (void) const |
| | Show the statusword in string(int) More...
|
| |
| virtual void | processData (size_t index, uint8_t *domain_address) |
| | Define a TPDO & RPDO process. More...
|
| |
|
std::string | GetDevState (void) |
| |
| virtual const ec_sync_info_t * | syncs () |
| | manage the syncs More...
|
| |
| virtual size_t | syncSize () |
| | size of sync More...
|
| |
| virtual const ec_pdo_entry_info_t * | channels () |
| | base method for PDO entries More...
|
| |
| virtual void | domains (DomainMap &domains) const |
| | base method for pdo domains More...
|
| |
| | Slave (uint32_t vendor_id, uint32_t product_id) |
| | the slave class constructor for EtherLAB API More...
|
| |
|
bool | isHomingEnable () const |
| |
|
bool | setHomingParam (int32_t HomingOffset, int8_t HomingMethod, uint32_t HomingSpeed, uint16_t HomingCurrentLimit) |
| |
|
int32_t | getHomingOffset (void) |
| |
|
int8_t | getHomingMethod (void) |
| |
|
uint32_t | getHomingSpeed (void) |
| |
|
uint16_t | getHomingCurrentLimit (void) |
| |
| void | setSlaveAlias (int alias) |
| | base method for set the slave alias More...
|
| |
| void | setSlavePosition (int position) |
| | base method for set the slave position More...
|
| |
| int | getSlaveAlias (void) |
| | base method for get the slave alias More...
|
| |
| int | getSlavePosition (void) |
| | base method for get the slave position More...
|
| |
|
|
int16_t | command [4] = {0,} |
| |
|
uint16_t | SensorL [9] = {0,} |
| |
|
uint16_t | SensorR [9] = {0,} |
| |
| const uint32_t | m_vendor_id |
| |
| const uint32_t | m_product_id |
| |
|
| int | slave_alias =0 |
| |
| int | slave_position =0 |
| |
|
bool | homing_flag_ = false |
| |
|
int32_t | mHomingOffset =0 |
| |
|
int8_t | mHomingMethod =0 |
| |
|
uint32_t | mHomingSpeed =0 |
| |
|
uint16_t | mHomingCurrentLimit =0 |
| |
Modified version of SimpleCAT.
EtherCAT API for Elmo Gold-DC-Whitle
- Version
- 1.1.0
◆ channels()
| virtual const ec_pdo_entry_info_t* hyuEcat::EcatKistSensor::channels |
( |
| ) |
|
|
inlinevirtual |
base method for PDO entries
- Returns
- NULL
Reimplemented from hyuEcat::Slave.
◆ domains()
| virtual void hyuEcat::EcatKistSensor::domains |
( |
DomainMap & |
domains | ) |
const |
|
inlinevirtual |
base method for pdo domains
- Parameters
-
Reimplemented from hyuEcat::Slave.
◆ Elmo_DeviceState()
| int hyuEcat::EcatKistSensor::Elmo_DeviceState |
( |
void |
| ) |
const |
|
inline |
Show the statusword in string(int)
- Returns
- state_
◆ initialized()
| bool hyuEcat::EcatKistSensor::initialized |
( |
| ) |
const |
|
inline |
Check the Elmo is Initialized.
Returns true if Elmo has reached "operation enabled" state. The transition through the state machine is handled automatically.
- Returns
- mixedboolean Success:1, False:0
◆ processData()
| virtual void hyuEcat::EcatKistSensor::processData |
( |
size_t |
index, |
|
|
uint8_t * |
domain_address |
|
) |
| |
|
inlinevirtual |
Define a TPDO & RPDO process.
- Parameters
-
| [in] | index | |
| [in] | domain_address | |
- Returns
- void
Reimplemented from hyuEcat::Slave.
◆ syncs()
| virtual const ec_sync_info_t* hyuEcat::EcatKistSensor::syncs |
( |
| ) |
|
|
inlinevirtual |
◆ syncSize()
| virtual size_t hyuEcat::EcatKistSensor::syncSize |
( |
| ) |
|
|
inlinevirtual |
The documentation for this class was generated from the following file:


A B C E F G I K L M N P Q R S U V X misc
| bit-package | bit: Classes and methods for fast memory-efficient boolean selections |
| all.bit | Summaries of boolean vectors |
| all.bitwhich | Summaries of boolean vectors |
| all.booltype | Summaries of boolean vectors |
| all.ri | Summaries of boolean vectors |
| all.which | Summaries of boolean vectors |
| any.bit | Summaries of boolean vectors |
| any.bitwhich | Summaries of boolean vectors |
| any.booltype | Summaries of boolean vectors |
| any.ri | Summaries of boolean vectors |
| any.which | Summaries of boolean vectors |
| anyDuplicated.rlepack | Hybrid Index, rle-pack utilities |
| anyNA.bit | Summaries of boolean vectors |
| anyNA.bitwhich | Summaries of boolean vectors |
| anyNA.booltype | Summaries of boolean vectors |
| anyNA.ri | Summaries of boolean vectors |
| anyNA.which | Summaries of boolean vectors |
| as.bit | Coercing to bit |
| as.bit.bit | Coercing to bit |
| as.bit.bitwhich | Coercing to bit |
| as.bit.double | Coercing to bit |
| as.bit.integer | Coercing to bit |
| as.bit.logical | Coercing to bit |
| as.bit.NULL | Coercing to bit |
| as.bit.ri | Coercing to bit |
| as.bit.which | Coercing to bit |
| as.bitwhich | Coercing to bitwhich |
| as.bitwhich.bit | Coercing to bitwhich |
| as.bitwhich.bitwhich | Coercing to bitwhich |
| as.bitwhich.double | Coercing to bitwhich |
| as.bitwhich.integer | Coercing to bitwhich |
| as.bitwhich.logical | Coercing to bitwhich |
| as.bitwhich.NULL | Coercing to bitwhich |
| as.bitwhich.ri | Coercing to bitwhich |
| as.bitwhich.which | Coercing to bitwhich |
| as.booltype | Coerce to booltype (generic) |
| as.booltype.default | Coerce to booltype (generic) |
| as.character.bit | Coerce bit to character |
| as.character.bitwhich | Coerce bitwhich to character |
| as.double.bit | Coercion from bit, bitwhich, which and ri to logical, integer, double |
| as.double.bitwhich | Coercion from bit, bitwhich, which and ri to logical, integer, double |
| as.double.ri | Coercion from bit, bitwhich, which and ri to logical, integer, double |
| as.integer.bit | Coercion from bit, bitwhich, which and ri to logical, integer, double |
| as.integer.bitwhich | Coercion from bit, bitwhich, which and ri to logical, integer, double |
| as.integer.ri | Coercion from bit, bitwhich, which and ri to logical, integer, double |
| as.logical.bit | Coercion from bit, bitwhich, which and ri to logical, integer, double |
| as.logical.bitwhich | Coercion from bit, bitwhich, which and ri to logical, integer, double |
| as.logical.ri | Coercion from bit, bitwhich, which and ri to logical, integer, double |
| as.logical.which | Coercion from bit, bitwhich, which and ri to logical, integer, double |
| as.ri | Coerce to ri |
| as.ri.default | Coerce to ri |
| as.ri.ri | Coerce to ri |
| as.which | Coercion to (positive) integer positions |
| as.which.bit | Coercion to (positive) integer positions |
| as.which.bitwhich | Coercion to (positive) integer positions |
| as.which.integer | Coercion to (positive) integer positions |
| as.which.logical | Coercion to (positive) integer positions |
| as.which.NULL | Coercion to (positive) integer positions |
| as.which.numeric | Coercion to (positive) integer positions |
| as.which.ri | Coercion to (positive) integer positions |
| as.which.which | Coercion to (positive) integer positions |
| bbatch | Balanced Batch sizes |
| bit | Create empty bit vector |
| bitsort | Low-level sorting: bit sort |
| bitwhich | Create bitwhich vector (skewed boolean) |
| bitwhich_representation | Diagnose representation of bitwhich |
| bit_anyDuplicated | bit unique and duplicated |
| bit_done | Initializing bit masks |
| bit_duplicated | bit unique and duplicated |
| bit_in | bit %in% |
| bit_init | Initializing bit masks |
| bit_intersect | bit set operations |
| bit_rangediff | bit range difference |
| bit_setdiff | bit set operations |
| bit_setequal | bit set operations |
| bit_setops | bit set operations |
| bit_sort | bit sort |
| bit_sort_unique | bit sort unique |
| bit_sumDuplicated | bit unique and duplicated |
| bit_symdiff | bit set operations |
| bit_unidup | bit unique and duplicated |
| bit_union | bit set operations |
| bit_unique | bit unique and duplicated |
| booltype | Diagnosing boolean types |
| booltypes | Boolean types |
| c.bit | Concatenating booltype vectors |
| c.bitwhich | Concatenating booltype vectors |
| c.booltype | Concatenating booltype vectors |
| chunk | Methods for chunked range index |
| chunk.default | Methods for chunked range index |
| chunks | Function for chunked range index |
| clone | Cloning ff and ram objects |
| clone.default | Cloning ff and ram objects |
| CoercionToStandard | Coercion from bit, bitwhich, which and ri to logical, integer, double |
| copy_vector | Copy atomic R vector |
| countsort | Low-level sorting: counting sort |
| Extract | Extract or replace part of an boolean vector |
| firstNA | Position of first NA |
| getsetattr | Attribute setting by reference |
| get_length | Get C length of a vector |
| in.bitwhich | Check existence of integers in table |
| intisasc | Hybrid Index, C-coded utilities |
| intisdesc | Hybrid Index, C-coded utilities |
| intrle | Hybrid Index, C-coded utilities |
| is.bit | Testing for boolean types |
| is.bitwhich | Testing for boolean types |
| is.booltype | Testing for boolean types |
| is.hi | Testing for boolean types |
| is.na.bit | Test for NA in bit and bitwhich |
| is.na.bitwhich | Test for NA in bit and bitwhich |
| is.ri | Testing for boolean types |
| is.sorted | Generics related to cache access |
| is.sorted<- | Generics related to cache access |
| is.which | Testing for boolean types |
| keyorder | Generics for in-RAM sorting and ordering |
| keysort | Generics for in-RAM sorting and ordering |
| keysortorder | Generics for in-RAM sorting and ordering |
| length.bit | Getting and setting length of bit, bitwhich and ri objects |
| length.bitwhich | Getting and setting length of bit, bitwhich and ri objects |
| length.ri | Getting and setting length of bit, bitwhich and ri objects |
| length<-.bit | Getting and setting length of bit, bitwhich and ri objects |
| length<-.bitwhich | Getting and setting length of bit, bitwhich and ri objects |
| max.bit | Summaries of boolean vectors |
| max.bitwhich | Summaries of boolean vectors |
| max.booltype | Summaries of boolean vectors |
| max.ri | Summaries of boolean vectors |
| max.which | Summaries of boolean vectors |
| maxindex | Get maxindex (length of boolean vector) and poslength (number of 'selected' elements) |
| maxindex.bit | Get maxindex (length of boolean vector) and poslength (number of 'selected' elements) |
| maxindex.bitwhich | Get maxindex (length of boolean vector) and poslength (number of 'selected' elements) |
| maxindex.default | Get maxindex (length of boolean vector) and poslength (number of 'selected' elements) |
| maxindex.logical | Get maxindex (length of boolean vector) and poslength (number of 'selected' elements) |
| maxindex.ri | Get maxindex (length of boolean vector) and poslength (number of 'selected' elements) |
| maxindex.which | Get maxindex (length of boolean vector) and poslength (number of 'selected' elements) |
| mergeorder | Generics for in-RAM sorting and ordering |
| mergesort | Generics for in-RAM sorting and ordering |
| mergesortorder | Generics for in-RAM sorting and ordering |
| merge_anyDuplicated | Fast functions for sorted sets of integer |
| merge_duplicated | Fast functions for sorted sets of integer |
| merge_first | Fast functions for sorted sets of integer |
| merge_firstin | Fast functions for sorted sets of integer |
| merge_firstnotin | Fast functions for sorted sets of integer |
| merge_in | Fast functions for sorted sets of integer |
| merge_intersect | Fast functions for sorted sets of integer |
| merge_last | Fast functions for sorted sets of integer |
| merge_lastin | Fast functions for sorted sets of integer |
| merge_lastnotin | Fast functions for sorted sets of integer |
| merge_match | Fast functions for sorted sets of integer |
| merge_notin | Fast functions for sorted sets of integer |
| merge_rangediff | Fast functions for sorted sets of integer |
| merge_rangein | Fast functions for sorted sets of integer |
| merge_rangenotin | Fast functions for sorted sets of integer |
| merge_rangesect | Fast functions for sorted sets of integer |
| merge_rev | Fast functions for sorted sets of integer |
| merge_setdiff | Fast functions for sorted sets of integer |
| merge_setequal | Fast functions for sorted sets of integer |
| merge_sumDuplicated | Fast functions for sorted sets of integer |
| merge_symdiff | Fast functions for sorted sets of integer |
| merge_union | Fast functions for sorted sets of integer |
| merge_unique | Fast functions for sorted sets of integer |
| Metadata | Generics related to cache access |
| min.bit | Summaries of boolean vectors |
| min.bitwhich | Summaries of boolean vectors |
| min.booltype | Summaries of boolean vectors |
| min.ri | Summaries of boolean vectors |
| min.which | Summaries of boolean vectors |
| na.count | Generics related to cache access |
| na.count<- | Generics related to cache access |
| nties | Generics related to cache access |
| nties<- | Generics related to cache access |
| nunique | Generics related to cache access |
| nunique<- | Generics related to cache access |
| nvalid | Generics related to cache access |
| physical | Physical and virtual attributes |
| physical.default | Physical and virtual attributes |
| physical<- | Physical and virtual attributes |
| physical<-.default | Physical and virtual attributes |
| PhysVirt | Physical and virtual attributes |
| poslength | Get maxindex (length of boolean vector) and poslength (number of 'selected' elements) |
| poslength.bit | Get maxindex (length of boolean vector) and poslength (number of 'selected' elements) |
| poslength.bitwhich | Get maxindex (length of boolean vector) and poslength (number of 'selected' elements) |
| poslength.default | Get maxindex (length of boolean vector) and poslength (number of 'selected' elements) |
| poslength.logical | Get maxindex (length of boolean vector) and poslength (number of 'selected' elements) |
| poslength.ri | Get maxindex (length of boolean vector) and poslength (number of 'selected' elements) |
| poslength.which | Get maxindex (length of boolean vector) and poslength (number of 'selected' elements) |
| print.bit | Print method for bit |
| print.bitwhich | Print method for bitwhich |
| print.physical | Physical and virtual attributes |
| print.ri | Range index |
| print.virtual | Physical and virtual attributes |
| quickorder | Generics for in-RAM sorting and ordering |
| quicksort | Generics for in-RAM sorting and ordering |
| quicksort2 | Low-level sorting: binary quicksort |
| quicksort3 | Low-level sorting: threeway quicksort |
| quicksortorder | Generics for in-RAM sorting and ordering |
| radixorder | Generics for in-RAM sorting and ordering |
| radixsort | Generics for in-RAM sorting and ordering |
| radixsortorder | Generics for in-RAM sorting and ordering |
| ramorder | Generics for in-RAM sorting and ordering |
| ramsort | Generics for in-RAM sorting and ordering |
| ramsortorder | Generics for in-RAM sorting and ordering |
| range.bit | Summaries of boolean vectors |
| range.bitwhich | Summaries of boolean vectors |
| range.booltype | Summaries of boolean vectors |
| range.ri | Summaries of boolean vectors |
| range.which | Summaries of boolean vectors |
| range_na | Get range and number of NAs |
| range_nanozero | Remove zeros and get range and number of NAs |
| range_sortna | Prepare for sorting and get range, number of NAs and unsortedness |
| rep.bit | Replicating bit and bitwhich vectors |
| rep.bitwhich | Replicating bit and bitwhich vectors |
| rep.booltype | Replicating bit and bitwhich vectors |
| repeat.time | Adaptive timer |
| repfromto | Virtual recycling |
| repfromto<- | Virtual recycling |
| rev.bit | Reversing bit and bitwhich vectors |
| rev.bitwhich | Reversing bit and bitwhich vectors |
| rev.booltype | Reversing bit and bitwhich vectors |
| rev.rlepack | Hybrid Index, rle-pack utilities |
| reverse_vector | Reverse atomic vector |
| ri | Range index |
| rlepack | Hybrid Index, rle-pack utilities |
| rlepack.integer | Hybrid Index, rle-pack utilities |
| rleunpack | Hybrid Index, rle-pack utilities |
| rleunpack.rlepack | Hybrid Index, rle-pack utilities |
| setattr | Attribute setting by reference |
| setattributes | Attribute setting by reference |
| shellorder | Generics for in-RAM sorting and ordering |
| shellsort | Generics for in-RAM sorting and ordering |
| shellsortorder | Generics for in-RAM sorting and ordering |
| Sorting | Generics for in-RAM sorting and ordering |
| still.identical | Test for C-level identity of two atomic vectors |
| str.bit | Str method for bit |
| str.bitwhich | Str method for bitwhich |
| sum.bit | Summaries of boolean vectors |
| sum.bitwhich | Summaries of boolean vectors |
| sum.booltype | Summaries of boolean vectors |
| sum.ri | Summaries of boolean vectors |
| sum.which | Summaries of boolean vectors |
| Summaries | Summaries of boolean vectors |
| summary.bit | Summaries of boolean vectors |
| summary.bitwhich | Summaries of boolean vectors |
| summary.booltype | Summaries of boolean vectors |
| summary.ri | Summaries of boolean vectors |
| summary.which | Summaries of boolean vectors |
| symdiff | Symmetric set complement |
| unattr | Attribute removal |
| unique.rlepack | Hybrid Index, rle-pack utilities |
| vecseq | Vectorized Sequences |
| virtual | Physical and virtual attributes |
| virtual.default | Physical and virtual attributes |
| virtual<- | Physical and virtual attributes |
| virtual<-.default | Physical and virtual attributes |
| xor | Boolean operators and functions |
| xor.bit | Boolean operators and functions |
| xor.bitwhich | Boolean operators and functions |
| xor.booltype | Boolean operators and functions |
| xor.default | Boolean operators and functions |
| xor.logical | Boolean operators and functions |
| !.bit | Boolean operators and functions |
| !.bitwhich | Boolean operators and functions |
| !=.bit | Boolean operators and functions |
| !=.bitwhich | Boolean operators and functions |
| !=.booltype | Boolean operators and functions |
| &.bit | Boolean operators and functions |
| &.bitwhich | Boolean operators and functions |
| &.booltype | Boolean operators and functions |
| .BITS | Initializing bit masks |
| ==.bit | Boolean operators and functions |
| ==.bitwhich | Boolean operators and functions |
| ==.booltype | Boolean operators and functions |
| [.bit | Extract or replace part of an boolean vector |
| [.bitwhich | Extract or replace part of an boolean vector |
| [<-.bit | Extract or replace part of an boolean vector |
| [<-.bitwhich | Extract or replace part of an boolean vector |
| [[.bit | Extract or replace part of an boolean vector |
| [[.bitwhich | Extract or replace part of an boolean vector |
| [[<-.bit | Extract or replace part of an boolean vector |
| [[<-.bitwhich | Extract or replace part of an boolean vector |
| |.bit | Boolean operators and functions |
| |.bitwhich | Boolean operators and functions |
| |.booltype | Boolean operators and functions |


Drivers
Choose your drivers
CompareDriver 1
Driver 2
Grand Prix
New Season
The new 2021 Season already started with some exciting battles and 3 new tracks such as the super
fast Imola Circuit in Italy, Portimao in the Algarve region and the new City Circuit in Jeddah.
Check the link to learn more


Today we’re going to take a look at a very common modeling task modeling hands. Hands are one of the most complex shapes on the human body to model. An arm is one thing, but another five appendages? Topology and mesh density can quickly get out of hand (pun intended). Furthermore, animated ready hands must be ready to deform in almost any shape while still looking good.
So without further ranting, here’s a couple tips for modeling your next hand. Once you reach the bottom, you can also download the final hand with loop flow notes using the Sketchfab link.
Reference…Reference….Reference!
Organic forms, especially those we’re most familiar with, require acute attention to reference. It’s easy to take as granted that we know what a human hand looks like, but once you begin modeling, it’s easy to assume forms and end up in the uncanny valley. Even when working with base meshes, reference is a necessity. Base meshes are all about recognizing the major forms of a model, that means paying attention to muscle and bone structure is just as important at this step as it is for sculpting or texturing.
For example, while working on this post, I initially modeled the back of the hand with inset loops near the knuckles, but after looking at my own hand, I realized that it would be more accurate to have the loops extend downwards across the hand because the whole area deforms in certain positions.
TLDR: Check your reference…and then check it again.
Identify Primary Loops
The human hand has a lot of primary loop locations. This is why it’s a safe bet to start identifying these before you build out much of the model. A great way to do this is by using the grease pencil tool over your reference image. Mark out anywhere that should have clean loops of edges. For example, the wrist, fingers, knuckles, and thumb pad. Marking these will help you avoid redoing work correcting edge loops that flow in the wrong ways.
Once you’ve marked your main loops build them out using geometry. You can automate this using something like Retopoflow. Remember to check your edge count in loops. Each finger should have the same number of loops. Sticking to multiple of 4 for loops is also general good practice. Pay special attention to the loop count of the wrist; 16 is generally plenty and will be at least close to the loop count of whatever arm you attach.
Do the Easy Stuff First
Next, use the loops you made to fill in the areas between them. If you see a problem coming at a loop transition, leave it and work on filling as much clean topology as you can. If you work too much to make a good transition area, only to need to fix it again, modeling can get frustrating very quickly. You’ll likely see most problems at the base of the thumb and between the fingers.
Fix Tricky Loop Transitions
Now you should have enough topology to know what your transition points need to be like. Now your topology skills really come into play. There is no fix all solution to transition points, but these principles are good guides: First, check your loop flows. The easiest way to get in a mess is linking one end of a loop to the wrong point on the opposite end. Second, learn loop reduction flows. These will be essential to ending flows so you don’t end up with dozens of edge loops at the wrist. And Lastly, persevere. Sometimes you just gotta keep trying new things until it works. Don’t be afraid to delete topology.
Make Your Rig Happy
Last, but not least, add deformation areas and make your rig (or rigger) happy. Deformation areas (marked in blue) help topology stretch properly in extreme positions. The best way to add these areas is to outset a grouping of faces by pressing I then O and adding a small loop around the area that needs extra geometry. Generally, the tops of joints need the most extra geometry. in some cases, it can be easier to add more loops instead, but this can also create extra to geometry to compress inside the joint.
Below you can see the final result and the main edge flow highlighted. You can also download the model from Sketchfab here.
If you enjoyed this post, please consider supporting the site on Patreon help pay for website costs and give me motivation to keep writing guides!
For some models, creating bevels is a simple as adding a bevel modifer. But for other models, more complex methods are needed. One of these methods is creating transitions between two bevel widths.  This short guide will show you the most optimal ways to create transitions between bevel widths.
Method #1 - Quick & Dirty
First, the quick and dirty method. If you’re in a pinch or if you’re modeling something that’s unlikely to be viewed close up, this is the method to use. This method involves using edge ceases to sharpen at variable levels. In this example, the sharp edge has a crease of 1.00 and the wider bevel has a crease of 0.00. To adjust the crease of an edge in Blender, use SHIFT-E.
Method #2 - Smooth Bevels
This method is a bit more complex and involves using the bevel tool (CTRL-B) to separately bevel each bevel width then combining the two bevels by cleaning up the merge point in step three. This method also using holding edges instead of edge creasing to have more control over the bevel profile.
Using this type of transition is perfect for important bevel transitions and high-poly modeling where model density is less restricted.
Method #3 - Sharp Bevels
This last method is for sharp chamfered bevels. Using creases and single segment bevels, it’s easy to create very clean transition points. The important step here is to merge the extra vertices in step four to restore the edge flow.
That concludes this brief intro to variable bevels! If this guide was useful to you, then please consider sharing it or contributing to the project’s Patreon page.
Let’s talk about Edge poles, those famously aggravating little points on a mesh that cause so many headaches for 3d artists around the world. Why are they so terrible? What can we do about them? And when are they actually good to use?
Edge poles are generally considered to vertices with more or less than 4 connecting vertices. On a polygon mesh, this means vertices with either 3 connecting edges or 5 or more connecting edges. Poles most commonly form when triangles or n-gons appearing in models, hence why such polygon types are generally avoided in 3d modeling. Triangulated meshes (such as game models, or photogrammetry models) are most notably known for consisting almost entirely of edge poles with very few 4-edge vertices, the same applies to meshes with large numbers of n-gons.
The Problem of Poles
So you might be wondering, why do edge poles get such a bad wrap? The primary reason is that an edge pole creates pinching around its perimeter when subdivisions or smoothing is applied. This is why a cylinder with a triangle cap looks so odd when applying subdivision surface smoothing. The example below shows why this can be a problem on curved surfaces. The cross-section view shows that the corner that contains a pole will yield an uneven surface when subdivisions are applied.
Despite the pinching created by poles, they are an important part of modeling and a necessary component for many modeling techniques and shapes. So this the rest of this post will attempt to explain a bit more about poles and how to use them effectively.
E-poles
E-poles are the most common pole type and consist of five edges intersecting at a single vertex. E-poles are most notorious for appearing when extruding faces on a mesh and for forming unwanted flat “corners” within the topology when edge loops meet or turn. E-poles are also what form concave corners in hard surface models.
N-poles
N-poles are vertices that consist of three intersecting edges. This type of pole is far less common, but often appearing around poles or inset parts of a mesh. In organic modeling, this pole is often known as the “nose” pole, since N-poles are often necessary for modeling the base of the nose. N-poles are also what form the corner of a cube or most other convex corners.
Other Pole Types
Poles with six or more edges are generally considered to be bad practice and almost never show up in good topology. Again, on flat surfaces, 6+ edge poles can be acceptable if absolutely needed, but this is a rare case.
When are Poles Ok?
You’ve probably come to realize that poles are inevitable, and required for proper topology. But when exactly do we know when a pole should or shouldn’t be where it is? It all comes down to curvature. If a pole is changing the curvature of the surface, then it should be removed or eliminated. This usually happens on corners or any other areas of extreme curvature. Of flat surfaces, less visible areas, or areas with a slight curvature like a cheek of a face are areas where poles are least destructive and are where you should try to place or move poles to.
Moving Poles: The Great Compromise
One of the most requested topics I’ve received is how to move poles. And for good reason, poles can be very difficult to move without modifying topology in an adverse way. In almost every circumstance model density must be changed to accommodate a change in pole locations, causing the topology to quickly become very sloppy if multiple edges need to be moved. This is why the best advice for moving poles is to not move them wherever possible by planning your pole locations is advance. It’s pretty easy to judge where a pole will form by looking at the major flows of a surface and where they intersect. That intersection is where a pole will appear. Luckily, it’s up to you where that intersection happens.
But, in the case that you do end up with a pole that needs to be moved, there are a number of options for moving poles depending on your needs. Every situation requires a slightly different approach, however, there are some general techniques for 3 and 5-edge poles that can be a good basis for moving a pole. Something to remember, whenever a pole is moved, one edge loop must be removed in the direction the pole is being moved, while another is subtracted from wherever the pole came from. The reason for this is that the edge loops must be redirected around the new location of the pole. Otherwise, an n-gon will appear.
That’s all! I hope this short primer on edge poles has given you a better understanding of how to use them effectively. If this guide was useful to you, then please consider sharing it or contributing to the project’s Patreon page.
If you’ve ever tried to model a car or any other shiny object, you know how hard it is to get perfect reflections outside of using CAD programs. It’s tedious and virtually impossible to get 100% right.
With that in mind, I thought I’d talk about modeling specifically for these types of surfaces and the best ways to make it as painless as possible. Regularly used subdivision modeling methods rarely have the level of precision needed to make these kinds of surfaces, so I’ll be covering how “hack” sub-d modeling to best apply A-class surfacing ideals to the practical methods of subdivision modeling.ideals to the practical methods of subdivision modeling.
Evenly and Sparsely Place Loops
Even spacing, while often unavoidable without adding useless edge loops, is a goal worth pursuing. Even spacing ensures curvatures stay correct by not introducing any irregular areas that might produce artifacts.
Because of the way subdivision surfaces smooth and subdivide, even adding an extra edge loop that “seems” to follow the surface of your model can cause minute distortions to reflections if placed incorrectly. This is why it’s best to keep the mesh as minimal as possible, for as long as possible. Keeping the mesh simple so you can understand what your topology is doing.
Minimize High-Density Edge Poles
Edges poles are well known for creating mesh artifacts and distortions. But they are often unavoidable in certain areas without sacrificing another part of the model. That’s why it’s best to move poles to areas of less importance or curvature to make them less noticeable, rather than detrimentally removing them. Remove any unneeded poles if possible, but fall back to moving them if you can’t remove them.
A big request has been for a post covering moving poles, so I’ll hopefully be working on a full guide covering this soon.
Make Curvature Contradictions After Finalization
Curvature contradictions, meaning things like door handles on a car, or buttons on a control panel can cause major problems with topology and reflections. The main problem is that these contradictions can almost never be isolated without either large amounts of holding edges or creasing with very high mesh density.
To solve this problem, it’s best to add contradictions after one or two levels of subsurface smoothing have been applied. This way, the curvature is finalized before it can be altered negatively by any additional edits.
Don’t use Holding Edges when Possible
While holding edges are a great thing, they almost always cause distortion on some part of a model by adding edges along the entire length of the area the loop runs. The alternative is to use creasing when possible.
Creasing, especially at high subdivision levels has almost the same effect as holding edges and can create topology that is much cleaner and easier to manipulate because it uses the extra subdivision of sub-surf.
Non-Destructive Sub-Surface
One benefit of non-destructive subdivision surfaces is that you can preview how the surfacing will look without finalizing it. This is an invaluable benefit of sub-d modeling that other modeling methods often lack.
Previewing how subdivisions will affect your topology is vital to making sure there are no distortions in your mesh. Because like I’ve said before, you never really know how it will be transformed by sub-d smoothing.
Use high contrast Materials during Modeling
One of the main difficulties in creating perfect reflections is previewing those reflections inside modeling apps. The default Matcaps built into 3d viewports are too low contrast to notice minute imperfections. That’s why using high contrast Matcaps or patterned reflection maps is a good idea for noticing things one normally wouldn’t.
Depending on your software of choice, you might have a Matcap viewer available or some other way to change the viewport material. If all else fails, a fallback is to render a preview of your mesh with a checkered map set as your environment texture.
That’s all! I hope this gave you some helpful tips for reducing mesh artifacts. But before I conclude, I want to thank CGcookie for graciously sponsoring this post. CGcookie has some fantastic modeling coursework that’s defiantly worth checking for both beginners and advanced artists.
So if you’re interested, check them out by clicking the banner below. :)
An essential skill of modeling is knowing how to properly reduce the number of edge loops from a high mesh density to a low density. This involves some tricky topology. So let’s have a look at how to best reduce the various flow types.
2-1 and 4-1
The 2-1 and 4-1 flows are the trickiest to handle. Most methods involve substantial distortion of topology and/or the addition of more loops to the left or right of the intersection.
So, after experimenting with different forms, the results above seem to offer the least mesh distortion despite containing Tris and N-gons.
I apologize to any quad purists out there for the lack of quads. ;)
3-1, 4-2, and 5-3
The three of these flows are very standard flows that involve redirecting the edge loops back towards their origin. This trick is very effective. and maintains almost perfect topology in most situations.
As you can see, the 4-2 and 5-3 flows follow the form of the 3-1 flow. With the only differing factor being the number of center loops. This shows just how adaptable this method of reduction can be.
Hope this helps! if so, be sure to hit one of those share buttons below!
Also, if you’re interested in supporting the content here on Topology Guides, please consider making a small donation to my Patreon page to help with the creation of new content!
I’ve talked quite a bit here on Topology Guides about integrating shapes into meshes. But until this point, I’ve overlooked a surprisingly adequate workaround to traditional modeling practices for integrating shapes onto a surface.
This workaround is the process of using “decal” meshes that hover over the surface of a primary mesh, yet seem to be fully integrated once shaded. The method I’m about to show you works mainly for protruding convex parts of an object. Such as a door handle or a button on a workstation.
For this process, all you need is the “decal” object you want to integrate, and the primary “surface” mesh.
Note: For smaller or concave decals, I highly recommend checking out DECALmachine. It’s a fantastic add-on that’s been spreading like wildfire in the Blender community the past few months.
Start Simple
In addition to the decal and surface we’re using, we’ll also need a 2d lattice roughly in the shape of the bottom of the decal. Along with that, be sure that the decal has a bottom rim with some type of bevel to make sure there’s a smooth transmission between the decal and surface in the later stages.
Once you have all these elements, lay them out in a similar fashion to the screenshot above before you move on to adding vertex groups.
Vertex Groups
We’ll need two vertex groups to get the decal working properly. One for the very outer rim of the decal, and another for the larger area around the base of the decal.
We’ll use these groups later for deforming the decal to the surface using a variety of methods for mesh deformation.
Using Lattices
After laying out the lattice and decal over the surface, you can start to use the lattice to shape the decal.
Start by applying the lattice to the decal using the lattice modifier. Now the lattice has total control over the decal, which isn’t quite what we want, so we’ll need to use the larger vertex group we created earlier to make sure the lattice deforms only the bottom areas of the decal.
After the decal is joined to the lattice, apply a shrinkwrap modifier to the lattice with the surface as the target. This should give a rough version of the final outcome. But don’t quit yet, there’s still a lot of perfecting to do.
Perfecting the Shape
To perfect the surface, the outer rim still needs to be adjusted. Otherwise, at certain low viewing angles, we can sometimes still see a slight gap between the two surfaces. Of course, if this gap isn’t visible on whatever model you’re using, then you can go skip this.
To adjust the rim, apply a shrinkwrap modifier to the decal with the surface as the target. Next, select the rim vertex group to make sure only the rim is affected.
Correcting Normals
At this point, you should have an almost perfect mesh uniform to the target surface, apart from some shading artifacts. If not, come back to this step later and have a look at the troubleshooting tips below.
If it all looks good, all that’s left is to apply some normal editing hacks to smooth out the shading. Again, this is also a very picky detail so you might be able to get away with skipping it if you’re not doing close-up renderings.
Start by adding a Data Transfer modifier with the surface as the target. Then you can set the settings as shown in the screenshot and click Generate Data Layers near the bottom of the modifier.
To briefly explain what’s going on here, the data transfer modifier can copy the normal information from the surface model and apply it to the decal. Which makes the Render Engine (or viewport) view the two models as a seamless surface. Of course, this only works if the two meshes are approximately in the same location, hence the need for the previous steps in this guide.
Troubleshooting
If everything went smoothly, great! If not, don’t worry, here are some tips that might help.
Origin Points
Having the origin points of the lattice and decal in the same spot is best when possible. Otherwise, sometimes the decal will not deform with the lattice correctly.
Applying Transforms
Make sure to apply the scale of all objects using CTRL-A.
Setting the Rim Shrinkwrap
If you notice a shadow under the decal, it’s most likely because there’s still a small gap between the surfaces. Adjusting the offset of the shrinkwrap can often solve it. This applies to intercepting pieces as well.
Tweak Data Transfer
If you’re having problems with the edge of the decal shading properly, try tweaking the settings of the Data Transfer modifier. Often times its normals that cause seemingly unsolvable problems. Don’t overlook them.
Still having Problems?
If you’re still having problems, I’ve uploaded an example file herethat has all the settings and modifiers laid out. So if all else fails, you can consult the file for help. ;)
That’s it! I hope this guide was useful. If it was, please consider making a small per-post donation to my Patreon page to support my work here on Topology Guides. I’d really appreciate it. :)
Today I’m going to be showing how to model what I called a chamfered cut, meaning a chamferd section of an edge, often found on hard-surface metal parts.
So without further introduction, let’s get to it.
1.
Start off with adding two edge loops to define the area that you want to chamfer.
2.
Next, bevel the edge created by adding the two edge loops to create the basic chamfered shape.
3.
Connect the two points of the triangles near the corners of the shape to make an edge loop down the center of the chamfered area. Also, connect the other two points of the triangles down to remove the n-gons from the model.
4.
Bevel the outer corners of the chamfered area a small amount to make sure the edges are held if subdivisions are applied.
5.
Add more holding edges to the outside to keep the shape contained, then add sub-surf if desired.
This time I’m going to show how to model a chamfered circle. I spent a fair bit of time on this one, trying to find a simple method for modeling the shape, and I think I found the simplest one. It’s not ideal (a few ngons), but the other methods I’ve found to be overly complex with too little payoff. Let me know if you have an even better method because I’d love to see it. 🙂
1.
Begin by creating a circle with a low edge count, in order to give a chamfered look. Then add a loop between each edge for the next step.
2.
Next, pull the middle top vertices up in order to begin creating a rounded top.
3.
Now bevel the center loop to complete the rounded look. Feel free to use as many segments as needed. Next, add a new circle above the mesh with the same edges count as the loops of the main mesh.
4.
The two loops can now be bridged by using the “bridge edge loops” tool in the edges menu (CTRL+E)
5.
Next, select the corners of the chamfered section and bevel them. Be sure not to bevel the top edges, so that the circular top maintains its shape.
6.
The last step is to add holding edges to all the sharp corners and add sub-surf as desired.
This shape is pretty simple. but a useful one if your modeling mechanical or sci-fi things with grips or ridges. So let’s get to it!
1.
Start by modeling the curved edge you need to incorporate the ridges into. I recommend modeling separate to your main model so that you can tile it later and then add it back in.
2.
Add two loops to define the inset and outset parts. If you want the inset and outset ridges to be the same width, then make sure the middle section is the same width as the two outer sections combined.
3.
Cut out the area you’d like to be inset.
4.
Add a quad to the first four vertices along what will be the wall of the inset. Make sure to model this quad to be properly aligned how you
like it, as the rest of the inset will be based upon this quad.
5.
Fill in the rest of the inset using the fill tool (F key), or using the F2 add-on for Blender to make it even quicker.
6.
Add holding edges or mean creases to hold the shape, then apply sub-surf. At this point, you can easily tile the ridges using an array and reintegrate it into your mesh.
I’m back! At least for now. Today i’m answering a question about cutting circular holes in curved surfaces. I learned this technique from the great Chris Kuhn a few years ago and have used it ever since.
1.
Start with even quads and an even mesh density.
2.
Add a Circle with an amount of sides relative to the density of the surface.
3.
Add a Shrinkwrap modifier to the circle, and set to project onto the surface area. (Be sure to set the direction and axis of projection.)
4.
Cut necessary areas in surface and merge vertexes along the edge of the hole with the circle. (Be sure to merge to the circle to maintain the circular shape.)
5.
Finish by checking geometry for errors or improper curvature.


OldHack: Old Hardware Classifieds [Google Spreadsheet as backend db + Handlebars + TableTop + jQuery]
Add your own hardware!
47hours project by Den Ivanov


Virtual Screnning
ID
Name
Distribution Configuration
None
None
File
File
Cancel
Next
Ready to Leave?
×
Select "Logout" below if you are ready to end your current session.


Start Bootstrap can help you build better websites using the Bootstrap CSS framework! Just download your template and start going, no strings attached!
Find Out MoreStart Bootstrap has everything you need to get your new website up and running in no time! All of the templates and themes on Start Bootstrap are open source, free to download, and easy to use. No strings attached!
Get Started!Ready to start your next project with us? That's great! Give us a call or send us an email and we will get back to you as soon as possible!
(+82)010-2693-2413


The complainant had made a covenant to be a determinant factor in bringing harmony to the dissonant situation, but there was still something consonant with the disagreement they were having. [G|D]
The lieutenant was malignant and indignant at the thought of being subservient to the dominant leader, but he could not ignore the pennant flying in the sky which symbolically represented his loyalty. [G|D]
The poignant reminder of the past was a remnant of the predominant effects of a recombinant virus that had left many pregnant women in its wake. [G|D]
The tenant felt repugnant at the thought of staying in a stagnant and ruminant environment, when all he wanted was something resonant with the beauty of nature. [G|D]


{% extends "base.html" %} {% block content %}
As part of CPython’s workflow, any non-trivial change to the codebase requires an accompanying Misc/News.d file in the pull request.
So far, the way you would add the news entry is by using blurb command line tool, that can be installed using PyPI and requires Python 3.5+.
But now, we’re going to defy the Zen of Python’s “there should be only one way to do it”, and present you with another way to do it: blurb-it. https://blurb-it.herokuapp.com/
blurb-it provides a web interface for you to create news entry to your own CPython pull request. That means, you can do this from your phone, as long as you have a webbrowser and connected to the internet.
blurb-it is a GitHub App owned by The PSF. You’ll need to install it and give write permission to your own fork’s cpython repo (so it can create the news file). Since the app will have write access to the repo, you should not install this on any other repo.
Please give this a try and let me know of any issues by filing a bug in the blurb-it repo.
The use of blurb-it is optional. You can still add news file using the blurb command line tool.


|
|
|
|
How to run a
REXX script?
From ATTAC, click "ATTAC->Run User (REXX) Scripts" from the menu. Step A: Click ATTAC on the Menu Bar Step B: Select Run User (REXX) Scripts. This brings up the following box. Step A: Here you can select the script you want to run. Step B: The drop down box has three options.
Tip: Another way to start a game is to click on the Saved Session. Click Load and then Click Open. I |
|
|
Copyright © 2005 All Rights Reserved. |


(+800)<PHONE_NUMBER>
<EMAIL_ADDRESS>Free Shipping
on All Orders Over
$75!
{{tkn.UserName}}
My Account
My Orders
WhishList
SignOut
SignUp & SignIn
Toggle navigation
{{proinfo.ProductName}}
{{cart_items}}
Toggle navigation
{{cat.CategoryName}}
{{subcat.SubcategoryName}}
{{subsubcat.SubsubcategoryName}}
Welcome
Get access to your Orders, Whishlist and Recomendations...!
Login
Enter UserName
Username is required
Enter password
Password is required
Forgot Password?
SignIn
SignUp
SignUp
Enter Name
person
Name is required
Enter Email
email
Email is required
Enter Password
vpn_key
Password is required
Enter Mobile number
Mobile number is required
Enter Address
Address is required
Gender:
Male
Female
Register
{{textmodal}}


Air India, the Country's proud flag carrier, also has the `biggest' MRO set up in India that can serve as a One-Stop-Shop for all Engineering requirements.Come, benefit from our wide expertise and extensive facilities for the A320 family, A310, A330,B737NG, B747-400, B777, B787, ATR & CRJ aircraft.Get high quality services at an economical cost from the most experienced MRO in India.
Non Destructive Testing Facility - NDT inspection using the magnetic particle, X-ray, fluorescent penetrant ,Ultrasonic & Eddy current inspection as well calibration of measuring Instruments, gauges etc.
Hydraulic Tubing/Hoses - Repair, Fabrication and Testing of Hydraulic and Oxygen pipes and hoses as per manufacturer's specification. We carry out 'perm swaging and in-situ repair' of tubes to reduce ground time of your aircraft.
Our structural Repairs cater to all kinds of Structural Repair work and can support AOG events, customized program as per your schedule and requirements.Our advanced state-of-the-art Composite Repair Facility is staffed with highly trained and experienced technicians.
We understand that the most visible part of aircraft is the cabin and needs specialized care and attention. We have skilled and experienced manpower and have over 35 years of experience in the field.More than 100,000 seats repaired/overhauled so far.
Asset Management - Aircraft Leases, Lease Return, new Aircraft acquisition, aging fleet disposal.
Quality Assurance & Continuing Airworthiness Management(CAM) Ensures quality at each stage. Material Management - OEM and Non-OEM Solutions and access to hundreds of Vendors


| Opcode* | Instruction | Op/En | 64-Bit Mode | Compat/Leg Mode | Description |
| FB | STI | NP | Valid | Valid | Set interrupt flag; external, maskable interrupts enabled at the end of the next instruction. |
| Op/En | Operand 1 | Operand 2 | Operand 3 | Operand 4 |
| NP | NA | NA | NA | NA |
If protected-mode virtual interrupts are not enabled, STI sets the interrupt flag (IF) in the EFLAGS register. After the IF flag is set, the processor begins responding to external, maskable interrupts after the next instruction is executed. The delayed effect of this instruction is provided to allow interrupts to be enabled just before returning from a procedure (or subroutine). For instance, if an STI instruction is followed by an RET instruction, the RET instruction is allowed to execute before external interrupts are recognized1. If the STI instruction is followed by a CLI instruction (which clears the IF flag), the effect of the STI instruction is negated.
The IF flag and the STI and CLI instructions do not prohibit the generation of exceptions and NMI interrupts. NMI interrupts (and SMIs) may be blocked for one macroinstruction following an STI.
When protected-mode virtual interrupts are enabled, CPL is 3, and IOPL is less than 3; STI sets the VIF flag in the EFLAGS register, leaving IF unaffected.
Table 4-15 indicates the action of the STI instruction depending on the processor’s mode of operation and the CPL/IOPL settings of the running program or procedure.
This instruction’s operation is the same in non-64-bit modes and 64-bit mode.
| PE | VM | IOPL | CPL | PVI | VIP | VME | STI Result |
| 0 | X | X | X | X | X | X | IF = 1 |
| 1 | 0 | ≥ CPL | X | X | X | X | IF = 1 |
| 1 | 0 | < CPL | 3 | 1 | 0 | X | VIF = 1 |
| 1 | 0 | < CPL | < 3 | X | X | X | GP Fault |
| 1 | 0 | < CPL | X | 0 | X | X | GP Fault |
| 1 | 0 | < CPL | X | X | 1 | X | GP Fault |
| 1 | 1 | 3 | X | X | X | X | IF = 1 |
| 1 | 1 | < 3 | X | X | 0 | 1 | VIF = 1 |
| 1 | 1 | < 3 | X | X | 1 | X | GP Fault |
| 1 | 1 | < 3 | X | X | X | 0 | GP Fault |
Notes: X = This setting has no impact.
| 1. | The STI instruction delays recognition of interrupts only if it is executed with EFLAGS.IF = 0. In a sequence of STI instructions, only the first instruction in the sequence is guaranteed to delay interrupts. In the following instruction sequence, interrupts may be recognized before RET executes: STI STI RET |
IF PE = 0 THEN IF ← 1; (* Set Interrupt Flag *) ELSE IF VM = 0 THEN IF IOPL ≥ CPL THEN IF ← 1; ELSE IF (IOPL < CPL) and (CPL = 3) and (VIP = 0) THEN VIF ← 1; ELSE #GP(0); FI; FI; ELSE IF IOPL = 3 THEN IF ← 1; ELSE IF ((IOPL < 3) and (VIP = 0) and (VME = 1)) THEN VIF ← 1; ELSE #GP(0); (* Trap to virtual-8086 monitor *) FI;) FI; FI; FI;
The IF flag is set to 1; or the VIF flag is set to 1.
| #GP(0) | If the CPL is greater (has less privilege) than the IOPL of the current program or procedure. |
| #UD | If the LOCK prefix is used. |
| #UD | If the LOCK prefix is used. |
Same exceptions as in protected mode.
Same exceptions as in protected mode.
Same exceptions as in protected mode.


AI-assisted Condition Mapping¶
This service helps maximise the number of times MyService can automatically match the veteran’s particular condition to one on the list of SoP conditions for which DVA provides treatment and compensation. It uses machine-learning techniques to match the veteran’s description of their diagnosis to a SoP condition - as well as conventional text-matching and spell-checking. The AI component exploits a Microsoft cloud-based commercial natural language processing API: Language Understanding Intelligence Service DVA staff claims assessors contributed expert guidance to its initial training.
The department has historically taken an entirely manual approach to classifying a condition: veterans write their medical condition in free form text on a form. This was either on a paper claim form or an online form called the Single Online Claim Form, or more-recently a drop-down box in MyService.
Claims assessment officers then attempt to match the veteran’s description to a recognised SoP condition, following policy guidance (Policy Guidance Note AN08, Full Federal Court Decision - Benjamin v The Repatriation Commission). This can involve time-consuming and frustrating correspondence with the applicant to clarify their condition: their description or their doctor’s description rarely matches one of the white-listed SoP conditions closely. The automatic approach removes this pain in a substantial portion of cases.
Additionally, it makes the most of Decision Ready Processing: it enables MyService to route more claims down the fast-tracked path automatically. Otherwise, these claims would miss out on the fast-tracked processing.
Before using this function, MyService automatically classified only 10.5% of claims into one of the fast-tracked categories: Straight-Through, Streamlined or Computer-Based Decisions. (Source: production logs for MyService from late December 2017 to end of June 2018 showed 6421 claims, of which only 671 were tagged for fast-tracked processing.)
In light of data collected from production, Gov Law Tech and DVA further tuned the AI. These changes took effect on 1 December 2018. This increased its effectiveness by 10 to 15% so MyService correctly fast-tracks around half of initial liability claims.


--- layout: post title: "Official NeurIPS Meetups" subtitle: "by Freiburg AI and Heidelberg AI" custom_date: "December 7-10, 2021" date: 2021-12-07 background: '/img/neurips_logo.png' future_date: True layer_shift: True ---
Dear fellow AI enthusiasts,
We are excited to announce that we will again be hosting a series of 4 NeurIPS events together with Freiburg AI.
Neurips is the largest AI conference worldwide and “Neurips Meetups” are described on the conference
webpage as follows:
“The goal of NeurIPS meetups is to open up access to communities worldwide and to connect
participants by geographic area and language. With this, we hope to support the growth of AI expertise
around the world, including in underrepresented communities in tech, and to fuel innovation responsibly.”
What this means is that we get access to all conference content in real-time, from which we will
select at least one talk per day to stream for you. For 4 days (Tuesday, 7. Dec to Friday, 10. Dec),
we will host digital meetups starting at 19:00 every day. Afterwards, we will discuss the talks in a joint
Q&A session.
The meetups will be hosted on Zoom:
https://us02web.zoom.us/j/3303598315
We also want to point to the NeurIPS code of conduct.
| Date | Topic | Speaker | More information |
|---|---|---|---|
| Tuesday, 7.12.2021 from 19:00 | Tutorial: "Machine Learning With Quantum Computers" | Maria Schuld (Xanadu, Startup Toronto) Juan Carrasquilla (Vector Institute for AI, Toronto) |
The tutorial targets a broad audience, and no prior knowledge of physics is
required. Meetup Event on Tuesday |
| Wednesday, 8.12.2021 from 19:00 | Keynote: "The Banality of Scale: A Theory on the Limits of Modeling Bias and Fairness Frameworks for Social Justice" | Mary Gray (Senior Principal Researcher at Microsoft Research) | Meetup Event on Wednesday |
| Thursday, 9.12.2021 from 19:00 | Keynote: "How Duolingo Uses AI to Assess, Engage and Teach Better" | Luis von Ahn (CEO of Duolingo) | Meetup Event on Thursday |
| Friday, 10.12.2021 from 19:00 | Keynote: The Collective Intelligence of Army Ants, and the Robots They Inspire | Radhika Nagpal (Professor at Harvard) | Meetup Event on Friday |


--- layout: post status: publish published: true title: Need for Speed Shift体验！ author: Leask author_login: leask author_email<EMAIL_ADDRESS>author_url: https://leaskh.com wordpress_id: 40 wordpress_url: http://leaskh.wordpress.com/2009/12/23/need-for-speed-shift%e4%bd%93%e9%aa%8c%ef%bc%81 date: '2009-12-23 15:48:45 +0800' date_gmt: '2009-12-23 15:48:45 +0800' categories: tags: [] comments: [] ---


History
Tic-Tac-Toe
Player X
Player O
0
:
0
Reset Game
Reset Scores
There are 255,168 possible outcomes to a game of Tic Tac Toe.


|
Breakout Game
|
The class is the base class for all the objects, including Paddle, Ball and Brick. Provides basic elements that can be shared among them, like get the borders of the object. More...
#include <Object.hpp>
Public Member Functions | |
| Object () | |
| Constructor. More... | |
| ~Object () | |
| Desctructor. More... | |
| int | getCeil () |
| Get the ceiling of the object. More... | |
| int | getBottom () |
| Get the bottom of the object. More... | |
| int | getLeft () |
| Get the left border of the object. More... | |
| int | getRight () |
| Get the right border of the object. More... | |
Protected Attributes | |
| int | x {1} |
| x pos in screen More... | |
| int | mw {1} |
| max x pos after setup More... | |
| int | y {1} |
| y pos in screen More... | |
| int | mh {1} |
| max y pos after setup More... | |
| int | w {1} |
| width of the object More... | |
| int | h {1} |
| height of the object More... | |
The class is the base class for all the objects, including Paddle, Ball and Brick. Provides basic elements that can be shared among them, like get the borders of the object.
| Object::Object | ( | ) |
Constructor.
| Object::~Object | ( | ) |
Desctructor.
| int Object::getBottom | ( | ) |
Get the bottom of the object.
| int Object::getCeil | ( | ) |
Get the ceiling of the object.
| int Object::getLeft | ( | ) |
Get the left border of the object.
| int Object::getRight | ( | ) |
Get the right border of the object.
|
protected |
height of the object
|
protected |
max y pos after setup
|
protected |
max x pos after setup
|
protected |
width of the object
|
protected |
x pos in screen
|
protected |
y pos in screen


BCB Director Russell pulls gun on police, then flees
by bdnews24.comPolice have seized bullets and drugs from the car of Bangladesh Cricket Board Director Showkat Aziz Russell after chasing the vehicle down in Narayanganj from Dhaka.
Russell, son of Partex Group Chairman MA Hashem, fled the scene after pulling a gun on policemen during an altercation amid traffic congestion in Dhaka’s Tejgaon in the early hours of Saturday, police said.
Police detained the driver, Russell’s wife Farah Russell and teenaged son from the car, an SUV, after finding 28 rounds of bullets, 1,200 yaba pills, 24 bottles of foreign liquor, 48 cans of beer and Tk 22,300 cash in Narayanganj.
Narayanganj Superintendent of Police Harun-or-Rashid told reporters on Saturday that Rashid’s driver and bodyguard were returning to Narayanganj after dropping him in Dhaka after Friday midnight.
The driver honked when their car was stuck in traffic congestion on the flyover in Tejgaon around 1am on Saturday.
It made Russell angry and he pulled a pistol on the police driver after getting of his car, the SP said. When he sensed that they were police, Russell fled with the gun, Rashid said.
Rashid’s driver and bodyguard then chased Russell’s car and informed others in Narayanganj when the car headed there, the SP said.
Around 3am, police stopped the vehicle at Siddhirganj and detained the trio after finding the bullets and drugs, he said.
A case was started against Russell and his chauffer, Mohammad Sumon, 29. The car was seized.
Hashem came to Narayanganj later and freed his daughter-in-law and grandson from police custody on condition that they will help recover the gun.
Russell is the chairman and managing director of Amber Group, which was formed after splitting Partex's businesses.


NOTE: TEST ON A DEVICE, THIS ALWAYS PASSES ON A SIMULATOR
This is an HTML file loaded from the app bundle, loading external JavaScript and CSS assets.
If the CSS load worked, the background will be yellow (#FFFF00).
If the JavaScript load worked, the button below should pop an alert.


I enjoy cooking and baking a lot during quarantine time, it helps me relieve stresses, calms me down and I get great joy from feeding my housemates! Some of my favorite chef include Julia Child, Samin Nosrat and James Oliver. Here are some of my kitchen projects.


{% extends 'apps-tabs.html' %} {% block head_title %}Account{% endblock %} {% load static %} {% block tab_content %}
From now on, every time you sign in you’ll be able to quickly access all of our exporting tools in one place. The tools are here to help your business succeed internationally.
You can start using any of our exporting tools by clicking on the tabs on your account.
Find thousands of exporting opportunities, search and apply within your industry or a specific country, and sign up for email alerts so you’re the first to know of new opportunities.
Promote your business overseas with your own business profile, add case studies of your company’s best work, and let overseas companies contact you directly.
Join major online marketplaces in other countries and access special offers negotiated by the Department for Business and Trade.


“When I was some years younger than I am at present, I used to employ myself in a more laborious diversion, which I learned from a Latin treatise of exercise, that is written with great erudition: It is there called the Skimachia, or the fighting with a man's own shadow, and consists in the brandishing of two short sticks grasped in each hand, and loaded with plugs of lead at either end. This opens the chest, exercises the limbs, and gives a man all the pleasure of boxing, without the blows.” — John Hamilton Moore, The Young Gentleman And Lady's Monitor, And English Teacher's Assistant


Using automated, prepared procedures to simplify your biological research.
Only select the parts that are required by your team. Enable and disable modules with ease.
Export the results in any format you need, whether you want to view them in your browser or use them directly in your reports.


How Open Source Audiovisual Tools Help Archivists (And You Too!)
hi!
Why?
Projects on amiaopensource
ffmprovisr!
CRALS and Sourcecaster
vrecord
audiorecorder
audiorecorder
microservices suites
resource lists
analog-inspection, open-workflows, time-based-media-art
Tools that evolved out of existing open source frameworks
qcli and QCTParse
IETF CELLAR
archivists contributing to OSS
conclusion!


JavaScript is disabled on your browser.
Skip navigation links
Overview
Package
Class
Tree
Deprecated
Index
Help
Prev
Next
Frames
No Frames
All Classes
Hierarchy For Package net.minecraft.block
Package Hierarchies:
All Packages
Class Hierarchy
java.lang.Object
net.minecraft.block.
Block
net.minecraft.block.
BlockAir
net.minecraft.block.
BlockBasePressurePlate
net.minecraft.block.
BlockPressurePlate
net.minecraft.block.
BlockPressurePlateWeighted
net.minecraft.block.
BlockBookshelf
net.minecraft.block.
BlockBreakable
net.minecraft.block.
BlockGlass
net.minecraft.block.
BlockIce
net.minecraft.block.
BlockPortal
net.minecraft.block.
BlockStainedGlass
net.minecraft.block.
BlockBush
(implements net.minecraftforge.common.
IPlantable
)
net.minecraft.block.
BlockCrops
(implements net.minecraft.block.
IGrowable
)
net.minecraft.block.
BlockCarrot
net.minecraft.block.
BlockPotato
net.minecraft.block.
BlockDeadBush
(implements net.minecraftforge.common.
IShearable
)
net.minecraft.block.
BlockDoublePlant
(implements net.minecraft.block.
IGrowable
, net.minecraftforge.common.
IShearable
)
net.minecraft.block.
BlockFlower
net.minecraft.block.
BlockLilyPad
net.minecraft.block.
BlockMushroom
(implements net.minecraft.block.
IGrowable
)
net.minecraft.block.
BlockNetherWart
net.minecraft.block.
BlockSapling
(implements net.minecraft.block.
IGrowable
)
net.minecraft.block.
BlockStem
(implements net.minecraft.block.
IGrowable
)
net.minecraft.block.
BlockTallGrass
(implements net.minecraft.block.
IGrowable
, net.minecraftforge.common.
IShearable
)
net.minecraft.block.
BlockButton
net.minecraft.block.
BlockButtonStone
net.minecraft.block.
BlockButtonWood
net.minecraft.block.
BlockCactus
(implements net.minecraftforge.common.
IPlantable
)
net.minecraft.block.
BlockCake
net.minecraft.block.
BlockCarpet
net.minecraft.block.
BlockCauldron
net.minecraft.block.
BlockClay
net.minecraft.block.
BlockColored
net.minecraft.block.
BlockCompressed
net.minecraft.block.
BlockCompressedPowered
net.minecraft.block.
BlockContainer
(implements net.minecraft.block.
ITileEntityProvider
)
net.minecraft.block.
BlockBeacon
net.minecraft.block.
BlockBrewingStand
net.minecraft.block.
BlockChest
net.minecraft.block.
BlockCommandBlock
net.minecraft.block.
BlockDaylightDetector
net.minecraft.block.
BlockDispenser
net.minecraft.block.
BlockDropper
net.minecraft.block.
BlockEnchantmentTable
net.minecraft.block.
BlockEnderChest
net.minecraft.block.
BlockEndPortal
net.minecraft.block.
BlockFlowerPot
net.minecraft.block.
BlockFurnace
net.minecraft.block.
BlockHopper
net.minecraft.block.
BlockJukebox
net.minecraft.block.
BlockMobSpawner
net.minecraft.block.
BlockNote
net.minecraft.block.
BlockPistonMoving
net.minecraft.block.
BlockSign
net.minecraft.block.
BlockSkull
net.minecraft.block.
BlockDirectional
net.minecraft.block.
BlockBed
net.minecraft.block.
BlockCocoa
(implements net.minecraft.block.
IGrowable
)
net.minecraft.block.
BlockFenceGate
net.minecraft.block.
BlockPumpkin
net.minecraft.block.
BlockRedstoneDiode
net.minecraft.block.
BlockRedstoneComparator
(implements net.minecraft.block.
ITileEntityProvider
)
net.minecraft.block.
BlockRedstoneRepeater
net.minecraft.block.
BlockDirt
net.minecraft.block.
BlockDoor
net.minecraft.block.
BlockDragonEgg
net.minecraft.block.
BlockEndPortalFrame
net.minecraft.block.
BlockFalling
net.minecraft.block.
BlockAnvil
net.minecraft.block.
BlockGravel
net.minecraft.block.
BlockSand
net.minecraft.block.
BlockFarmland
net.minecraft.block.
BlockFence
net.minecraft.block.
BlockFire
net.minecraft.block.
BlockGlowstone
net.minecraft.block.
BlockGrass
(implements net.minecraft.block.
IGrowable
)
net.minecraft.block.
BlockHardenedClay
net.minecraft.block.
BlockHugeMushroom
net.minecraft.block.
BlockLadder
net.minecraft.block.
BlockLeavesBase
net.minecraft.block.
BlockLeaves
(implements net.minecraftforge.common.
IShearable
)
net.minecraft.block.
BlockNewLeaf
net.minecraft.block.
BlockOldLeaf
net.minecraft.block.
BlockLever
net.minecraft.block.
BlockLiquid
net.minecraft.block.
BlockDynamicLiquid
net.minecraft.block.
BlockStaticLiquid
net.minecraft.block.
BlockMelon
net.minecraft.block.
BlockMycelium
net.minecraft.block.
BlockNetherrack
net.minecraft.block.
BlockOre
net.minecraft.block.
BlockPackedIce
net.minecraft.block.
BlockPane
net.minecraft.block.
BlockStainedGlassPane
net.minecraft.block.
BlockPistonBase
net.minecraft.block.
BlockPistonExtension
net.minecraft.block.
BlockQuartz
net.minecraft.block.
BlockRailBase
net.minecraft.block.
BlockRail
net.minecraft.block.
BlockRailDetector
net.minecraft.block.
BlockRailPowered
net.minecraft.block.
BlockRedstoneLight
net.minecraft.block.
BlockRedstoneOre
net.minecraft.block.
BlockRedstoneWire
net.minecraft.block.
BlockReed
(implements net.minecraftforge.common.
IPlantable
)
net.minecraft.block.
BlockRotatedPillar
net.minecraft.block.
BlockHay
net.minecraft.block.
BlockLog
net.minecraft.block.
BlockNewLog
net.minecraft.block.
BlockOldLog
net.minecraft.block.
BlockSandStone
net.minecraft.block.
BlockSilverfish
net.minecraft.block.
BlockSlab
net.minecraft.block.
BlockStoneSlab
net.minecraft.block.
BlockWoodSlab
net.minecraft.block.
BlockSnow
net.minecraft.block.
BlockSnowBlock
net.minecraft.block.
BlockSoulSand
net.minecraft.block.
BlockSponge
net.minecraft.block.
BlockStairs
net.minecraft.block.
BlockStone
net.minecraft.block.
BlockObsidian
net.minecraft.block.
BlockStoneBrick
net.minecraft.block.
BlockTNT
net.minecraft.block.
BlockTorch
net.minecraft.block.
BlockRedstoneTorch
net.minecraft.block.
BlockTrapDoor
net.minecraft.block.
BlockTripWire
net.minecraft.block.
BlockTripWireHook
net.minecraft.block.
BlockVine
(implements net.minecraftforge.common.
IShearable
)
net.minecraft.block.
BlockWall
net.minecraft.block.
BlockWeb
net.minecraft.block.
BlockWood
net.minecraft.block.
BlockWorkbench
net.minecraft.block.
Block.SoundType
net.minecraft.block.
BlockEventData
net.minecraft.block.
BlockPortal.Size
net.minecraft.block.
BlockRailBase.Rail
net.minecraft.block.
BlockSourceImpl
(implements net.minecraft.dispenser.
IBlockSource
)
net.minecraft.tileentity.
TileEntity
net.minecraft.block.
BlockJukebox.TileEntityJukebox
Interface Hierarchy
net.minecraft.block.
IGrowable
net.minecraft.block.
ITileEntityProvider
Enum Hierarchy
java.lang.Object
java.lang.Enum<E> (implements java.lang.Comparable<T>, java.io.Serializable)
net.minecraft.block.
BlockPressurePlate.Sensitivity
Skip navigation links
Overview
Package
Class
Tree
Deprecated
Index
Help
Prev
Next
Frames
No Frames
All Classes


An open source map visualization of public art in San José, California
There are so many incredible murals and public art in San José, California. This data visualization map is to help community members find public art and murals.
This project came out of a discussion with community members and Empire Seven Studios, a local art studio located in Japantown, San José, California. For the initial version of the map, Yan-Yin Choy researched local public art and murals from online sources. The data is updated as of October 1, 2017.
This is an open source project is maintained by Code for San José volunteers.
You are welcome to contribute to this project -- we need researchers, designers, developers and map enthusiasts! View our GitHub repository.