wblut / he_mesh Goto Github PK

@Override
	public double normalizeSelf() {
		final double d = getLength();
		if (WB_Epsilon.isZero(d)) {
			set(0, 0, 0);
		} else {
			set(xd() / d, yd() / d, zd() / d);
		}
		return d;
}

add_library('peasycam')
add_library('hemesh')

def setup():
    size(1000, 600, P3D)
    smooth(8)
           
    global mesh, render
    mesh = HE_Mesh(HEC_Icosahedron())
    render = WB_Render(this)
    cam = PeasyCam(this, 800)

def draw():
    background('#DCDCDC')
    lights()
    
    render.drawFaces(mesh)

def keyReleased():
    # select a face at random
    # compute its center and place a new vertex
    # create 3 new faces around that new vertex
    # remove old face

#Jython2.7
add_library('hemesh')

from wblut.external.straightskeleton import * 

verts = [PVector(208, 131),PVector(213, 142),PVector(168, 141),PVector(260, 168),PVector(246, 149),PVector(277, 142),
        PVector(271, 163),PVector(302, 180),PVector(268, 173),PVector(305, 196),PVector(319, 225),PVector(367, 214),
        PVector(423, 169),PVector(471, 160),PVector(540, 208),PVector(588, 268),PVector(616, 270),PVector(644, 308),
        PVector(630, 446),PVector(647, 472),PVector(641, 459),PVector(656, 467),PVector(660, 450),PVector(646, 423),
        PVector(687, 447),PVector(666, 495),PVector(651, 495),PVector(711, 580),PVector(728, 584),PVector(714, 557),
        PVector(746, 560),PVector(735, 569),PVector(744, 617),PVector(769, 594),PVector(753, 624),PVector(771, 628),
        PVector(793, 700),PVector(842, 708),PVector(871, 759),PVector(902, 780),PVector(891, 788),PVector(871, 773),
        PVector(887, 799),PVector(947, 774),PVector(964, 782),PVector(978, 689),PVector(985, 678),PVector(990, 695),
        PVector(984, 555),PVector(868, 338),PVector(854, 294),PVector(869, 316),PVector(887, 314),PVector(892, 366),
        PVector(895, 322),PVector(805, 196),PVector(747, 61),PVector(759, 59),PVector(753, 43),PVector(691, 33),
        PVector(683, 98),PVector(661, 72),PVector(355, 83),PVector(333, 46),PVector(35, 70),PVector(70, 144),
        PVector(50, 165),PVector(77, 154),PVector(87, 125),PVector(99, 139),PVector(106, 118),PVector(122, 139),
        PVector(89, 152),PVector(169, 124)]


def setup():
    size(1360, 840, P2D)
    background("#FFFFFF")
    strokeWeight(4)
    fill(0)
    
    # number of vertices
    N = len(verts)
    
    # corner
    corners = [Corner(p.x, p.y) for p in verts]
    
    # edges
    edges = Loop()
    for i in xrange(N):
        edges.append(Edge(corners[i], corners[(i+1)%N]))
    
    # speeds
    speeds = []
    for i in xrange(N):        
        pv = verts[(i-1)%N] #prev vertex
        cv = verts[i] #current vertex
        nv = verts[(i+1)%N] #next vertex
        s = speed(pv, cv, nv)
        speeds.append(s)
        
    # apply speed to edges
    for i, e in enumerate(edges):
        e.machine = Machine(speeds[i])

        
    out = LoopL()
    out.add(edges)

    skel = Skeleton(out, True)
    skel.skeleton()
    faces = skel.output.faces.values()
    

    faceList = []

    for face in faces:
        temp = []
        for ptgroup in face.points:
            for i, p in enumerate(ptgroup):
                temp.append(p)
        faceList.append(temp)
        
        
                
    strokeWeight(1.3)
    for face in faceList:
        for p1, p2 in zip(face, face[1:] + face[:1]):
            line(p1.x, p1.y, p2.x, p2.y)

    for i, p in enumerate(verts):
        text(i, p.x, p.y)
    
    noLoop()
    
    

    
        
def speed(pv, cv, nv):
    
    '''Returns a float.
       Computes the speed of a vertex given both its previous and next neighbors'''
            
    vec1 = PVector.sub(cv, pv).normalize()
    vec2 = PVector.sub(nv, cv).normalize()

    a = angle(vec1, vec2)
    s = 1 / sin(a*.5) #speed  
    
    return s

 
def angle(vec1, vec2):
    
    '''Returns a float.
       Computes the angle between 2 vectors'''
    
    a = PI - PVector.angleBetween(vec1, vec2) 
        
    if vec1.cross(vec2).z > 0:
        a = TWO_PI - a
        
    return a

Cork Boolean Library
Welcome to the Cork Boolean/CSG library. Cork is designed to support Boolean operations between triangle meshes.

import wblut.processing.*;

HE_Mesh m1, m2;
PeasyCam cam;

WB_Render3D render;
void setup() {
  size(1000, 1000, P3D);
  perspective(60 * DEG_TO_RAD, width/float(height), 2, 6000);
  smooth(8);
  background(55); 
  render=new WB_Render3D(this);
  cam = new PeasyCam(this, 40);
  create();
}

void create() {

  m1 = new HE_Mesh(new HEC_FromOBJFile("C:/Users/solub/Desktop/m1.obj"));
  m2 = new HE_Mesh(new HEC_FromOBJFile("C:/Users/solub/Desktop/m2.obj"));
  WB_Transform3D T=new WB_Transform3D(m1.getFaceCenter(6), m1.getFaceNormal(6), m2.getFaceCenter(8), m2.getFaceNormal(8).mul(-1));
  m1.transformSelf(T);// or .applySelf(T)
}


void draw() {
  background(50);
  stroke(0);
  render.drawFaces(m1);
  render.drawFaces(m2);
}