FVECT.FTINY) {\\n break;\\n }\\n }\\n if (i >= nroots) {\\n return (0);\\t\\t\\t/* no positive root */\\n }\\n\\n if (t >= r.rot) {\\n return (0);\\t\\t\\t/* other is closer */\\n }\\n\\n r.ro = so;\\n r.rot = t;\\n /* compute normal */\\n a = ap[3];\\n if (so.otype == OTYPES.OBJ_BUBBLE) {\\n a = -a;\\t\\t\\t/* reverse */\\n }\\n for (i = 0; i < 3; i++) {\\n r.rop.data[i] = r.rorg.data[i] + r.rdir.data[i] * t;\\n r.ron.data[i] = (r.rop.data[i] - ap[i]) / a;\\n }\\n r.rod = -FVECT.DOT(r.rdir, r.ron);\\n r.rox = null;\\n r.pert.data[0] = r.pert.data[1] = r.pert.data[2] = 0.0;\\n r.uv[0] = r.uv[1] = 0.0;\\n\\n return (1);\\t\\t\\t/* hit */\\n }\",\n \"@Test\\n\\tpublic void testSphereRadiusOne()\\n\\t{\\n\\t\\tfinal EllipseRegionOfInterest ellipse = new EllipseRegionOfInterest( 3 );\\n\\t\\tellipse.setOrigin( new double[] { 1, 1, 1 } );\\n\\t\\tellipse.setRadius( 1 );\\n\\t\\ttestEllipse( ellipse );\\n\\n\\t}\",\n \"void setupSpheres() {\\n\\n // create a Switch for the spheres, allow switch changes\\n spheresSwitch = new Switch(Switch.CHILD_ALL);\\n spheresSwitch.setCapability(Switch.ALLOW_SWITCH_WRITE);\\n\\n // Set up an appearance to make the Sphere with objColor ambient,\\n // black emmissive, objColor diffuse and white specular coloring\\n Material material = new Material(objColor, black, objColor, white, 32);\\n Appearance appearance = new Appearance();\\n appearance.setMaterial(material);\\n\\n // create a sphere and put it into a shared group\\n Sphere sphere = new Sphere(0.5f, appearance);\\n SharedGroup sphereSG = new SharedGroup();\\n sphereSG.addChild(sphere);\\n\\n // create a grid of spheres in the z=0 plane\\n // each has a TransformGroup to position the sphere which contains\\n // a link to the shared group for the sphere\\n for (int y = -2; y <= 2; y++) {\\n for (int x = -2; x <= 2; x++) {\\n TransformGroup tg = new TransformGroup();\\n tmpVector.set(x * 1.2f, y * 1.2f, -0.1f);\\n tmpTrans.set(tmpVector);\\n tg.setTransform(tmpTrans);\\n tg.addChild(new Link(sphereSG));\\n spheresSwitch.addChild(tg);\\n }\\n }\\n }\",\n \"public Sphere (final Point3 c, final double r, final Material material) {\\n super(material);\\n\\n this.c = c;\\n this.r = r;\\n }\",\n \"public void texturedSphere(float r, PImage t) {\\n int v1, v11, v2;\\n r = (r + 240 ) * 0.33f;\\n// tint(255, 48);\\n beginShape(TRIANGLE_STRIP);\\n texture(t);\\n float iu=(float)(t.width-1)/(sDetail);\\n float iv=(float)(t.height-1)/(sDetail);\\n float u=0, v=iv;\\n for (int i = 0; i < sDetail; i++) {\\n vertex(0, -r, 0, u, 0);\\n vertex(sphereX[i]*r, sphereY[i]*r, sphereZ[i]*r, u, v);\\n u+=iu;\\n }\\n vertex(0, -r, 0, u, 0);\\n vertex(sphereX[0]*r, sphereY[0]*r, sphereZ[0]*r, u, v);\\n endShape(); \\n \\n // Middle rings\\n int voff = 0;\\n for (int i = 2; i < sDetail; i++) {\\n v1=v11=voff;\\n voff += sDetail;\\n v2=voff;\\n u=0;\\n// tint(255, 255);\\n beginShape(TRIANGLE_STRIP);\\n texture(t);\\n for (int j = 0; j < sDetail; j++) {\\n vertex(sphereX[v1]*r, sphereY[v1]*r, sphereZ[v1++]*r, u, v);\\n vertex(sphereX[v2]*r, sphereY[v2]*r, sphereZ[v2++]*r, u, v+iv);\\n u+=iu;\\n }\\n \\n // Close each ring\\n v1=v11;\\n v2=voff;\\n vertex(sphereX[v1]*r, sphereY[v1]*r, sphereZ[v1]*r, u, v);\\n vertex(sphereX[v2]*r, sphereY[v2]*r, sphereZ[v2]*r, u, v+iv);\\n endShape();\\n v+=iv;\\n }\\n u=0;\\n \\n // Add the northern cap\\n// tint(255, 131);\\n beginShape(TRIANGLE_STRIP);\\n texture(t);\\n for (int i = 0; i < sDetail; i++) {\\n v2 = voff + i;\\n vertex(sphereX[v2]*r, sphereY[v2]*r, sphereZ[v2]*r, u, v);\\n vertex(0, r, 0, u, v+iv); \\n u+=iu;\\n }\\n vertex(sphereX[voff]*r, sphereY[voff]*r, sphereZ[voff]*r, u, v);\\n endShape();\\n }\",\n \"public Sphere(Point3 c, double r, Material material) {\\n\\t\\tsuper(material);\\n\\t\\tthis.c = c;\\n\\t\\tthis.r = r;\\n\\t}\",\n \"public float sphereRadius() {\\r\\n\\t\\treturn LeapJNI.Hand_sphereRadius(this.swigCPtr, this);\\r\\n\\t}\",\n \"public static Scene scene8() {\\r\\n\\t\\t// Define basic properties of the scene\\r\\n\\t\\tScene finalScene = new Scene().initAmbient(new Vec(1.0))\\r\\n\\t\\t\\t\\t.initCamera(/* Camera Position = */new Point(0.0, 2.0, 6.0),\\r\\n\\t\\t\\t\\t\\t\\t/* Towards Vector = */ new Vec(0.0, -0.1 ,-1.0),\\r\\n\\t\\t\\t\\t\\t\\t/* Up vector = */new Vec(0.0, 1.0, 0.0),\\r\\n\\t\\t\\t\\t\\t\\t/*Distance to plain =*/ 1.5)\\r\\n\\t\\t\\t\\t.initName(\\\"scene8\\\").initAntiAliasingFactor(1)\\r\\n\\t\\t\\t\\t.initBackgroundColor(new Vec(0.81,0.93,1))\\r\\n\\t\\t\\t\\t.initRenderRefarctions(true).initRenderReflections(true).initMaxRecursionLevel(3);\\r\\n\\t\\t// Add Surfaces to the scene.\\r\\n\\r\\n\\t\\tShape plainShape = new Plain(new Vec(0.0,-1,0.0), new Point(0.0, -1, 0.0));\\r\\n\\t\\tMaterial plainMat = Material.getMetalMaterial().initKa(new Vec(0.2)).initReflectionIntensity(0.1);\\r\\n\\t\\tSurface plainSurface = new Surface(plainShape, plainMat);\\r\\n\\t\\tfinalScene.addSurface(plainSurface);\\r\\n\\r\\n\\t\\tShape transparentSphere = new Sphere(new Point(0, 10, -25), 10);\\r\\n\\t\\tMaterial transparentSphereMat = Material.getGlassMaterial(false)\\r\\n\\t\\t\\t\\t.initRefractionIndex(0).initReflectionIntensity(0.4).initKs(new Vec(1.0)).initKd(new Vec(0));\\r\\n\\t\\tSurface transparentSphereSurface = new Surface(transparentSphere, transparentSphereMat);\\r\\n\\t\\tfinalScene.addSurface(transparentSphereSurface);\\r\\n\\r\\n\\t\\tdouble[] radiuses = new double[] { 0.3, 0.8, 1, 1.5, 2, 1.4, 0.2, 0.9, 1.2, 2.1 };\\r\\n\\r\\n\\t\\tfor (int i = -10; i < 10; i+=3) {\\r\\n\\t\\t\\tint sphereCenterZ = -5 + (int)(Math.random() * 3);\\r\\n\\t\\t\\tint radiusIndex = (int)(Math.random() * 10);\\r\\n\\t\\t\\tdouble radius = radiuses[radiusIndex];\\r\\n\\t\\t\\tShape distantSphere1 = new Sphere(new Point(i, radiuses[radiusIndex] - 1, sphereCenterZ), radius);\\r\\n\\t\\t\\tMaterial distantSphere1Mat = Material.getRandomMaterial();\\r\\n\\t\\t\\tSurface distantSphere1Surface = new Surface(distantSphere1, distantSphere1Mat);\\r\\n\\t\\t\\tfinalScene.addSurface(distantSphere1Surface);\\r\\n\\t\\t}\\r\\n\\r\\n\\t\\t// Add light sources:\\r\\n\\t\\tLight dirLight = new DirectionalLight(new Vec(-4.0, -1.0, -2.5), new Vec(0.3));\\r\\n\\t\\tfinalScene.addLightSource(dirLight);\\r\\n\\r\\n\\t\\tdirLight = new DirectionalLight(new Vec(-4.0, -1.0, -2.5), new Vec(0.3));\\r\\n\\t\\tfinalScene.addLightSource(dirLight);\\r\\n\\r\\n\\t\\treturn finalScene;\\r\\n\\t}\",\n \"public Sphere(Point3D c, double r, Color color)\\r\\n\\t{\\r\\n\\t\\tthis(c, r);\\r\\n\\t\\tsuper._emission = color;\\r\\n\\t}\",\n \"public void makeCube (int subdivisions)\\r\\n {\\r\\n \\tfloat horz[] = new float[subdivisions + 1];\\r\\n \\tfloat vert[] = new float[subdivisions + 1];\\r\\n \\t\\r\\n \\t\\r\\n \\t// Front face\\r\\n \\tPoint p1 = new Point(-0.5f, -0.5f, 0.5f);\\r\\n \\tPoint p2 = new Point(0.5f, -0.5f, 0.5f);\\r\\n \\tPoint p3 = new Point(0.5f, 0.5f, 0.5f);\\r\\n \\tPoint p4 = new Point(-0.5f, 0.5f, 0.5f);\\r\\n \\t\\r\\n \\tfloat h = p1.x;\\r\\n \\tfloat v = p1.y;\\r\\n \\t\\r\\n \\tfor( int i = 0; i <= subdivisions; i++ )\\r\\n \\t{\\r\\n \\t\\thorz[i] = h;\\r\\n \\t\\th = h + (float)(1/(float)subdivisions);\\r\\n \\t}\\r\\n \\t\\r\\n \\tfor( int i = 0; i <= subdivisions; i++)\\r\\n \\t{\\r\\n \\t\\tvert[i] = v;\\r\\n \\t\\tv = v + (float)(1/(float)subdivisions);\\r\\n \\t}\\r\\n \\t\\r\\n \\tfor( int j = 0; j < vert.length - 1; j ++)\\r\\n \\t\\tfor( int k = 0; k < horz.length - 1; k ++)\\r\\n \\t\\t{\\r\\n \\t\\t\\tPoint tempP1 = new Point(horz[k], vert[j], 0.5f);\\r\\n \\t\\t\\tPoint tempP2 = new Point(horz[k + 1], vert[j], 0.5f);\\r\\n \\t\\t\\tPoint tempP3 = new Point(horz[k + 1], vert[j + 1], 0.5f);\\r\\n \\t\\t\\tPoint tempP4 = new Point(horz[k], vert[j + 1], 0.5f);\\r\\n \\t\\t\\t\\r\\n \\t\\t\\taddTriangle(tempP1.x, tempP1.y, tempP1.z, tempP3.x, tempP3.y, tempP3.z, tempP4.x, tempP4.y, tempP4.z);\\r\\n \\t\\t\\taddTriangle(tempP1.x, tempP1.y, tempP1.z, tempP2.x, tempP2.y, tempP2.z, tempP3.x, tempP3.y, tempP3.z);\\r\\n \\t\\t\\t\\r\\n \\t\\t}\\r\\n \\t\\r\\n \\t// Back face\\r\\n \\tp1.y = p1.z = -0.5f;\\r\\n \\tp1.x = 0.5f;\\r\\n \\tp2.x = p2.y = p2.z = -0.5f;\\r\\n \\tp3.x = p3.z = -0.5f;\\r\\n \\tp3.y = 0.5f;\\r\\n \\tp4.x = p4.y = 0.5f;\\r\\n \\tp4.z = -0.5f;\\r\\n \\t\\r\\n \\th = p1.x;\\r\\n \\tv = p1.y;\\r\\n \\t\\r\\n \\t\\r\\n \\tfor( int i = 0; i <= subdivisions; i++ )\\r\\n \\t{\\r\\n \\t\\thorz[i] = h;\\r\\n \\t\\th = h - (float)(1/(float)subdivisions);\\r\\n \\t}\\r\\n \\t\\r\\n \\tfor( int i = 0; i <= subdivisions; i++)\\r\\n \\t{\\r\\n \\t\\tvert[i] = v;\\r\\n \\t\\tv = v + (float)(1/(float)subdivisions);\\r\\n \\t}\\r\\n \\t\\r\\n \\tfor( int j = 0; j < vert.length - 1; j ++)\\r\\n \\t\\tfor( int k = 0; k < horz.length - 1; k ++)\\r\\n \\t\\t{\\r\\n \\t\\t\\tPoint tempP1 = new Point(horz[k], vert[j], -0.5f);\\r\\n \\t\\t\\tPoint tempP2 = new Point(horz[k + 1], vert[j], -0.5f);\\r\\n \\t\\t\\tPoint tempP3 = new Point(horz[k + 1], vert[j + 1], -0.5f);\\r\\n \\t\\t\\tPoint tempP4 = new Point(horz[k], vert[j + 1], -0.5f);\\r\\n \\t\\t\\t\\r\\n \\t\\t\\taddTriangle(tempP1.x, tempP1.y, tempP1.z, tempP3.x, tempP3.y, tempP3.z, tempP4.x, tempP4.y, tempP4.z);\\r\\n \\t\\t\\taddTriangle(tempP1.x, tempP1.y, tempP1.z, tempP2.x, tempP2.y, tempP2.z, tempP3.x, tempP3.y, tempP3.z);\\r\\n \\t\\t\\t\\r\\n \\t\\t}\\r\\n \\t\\r\\n \\t// Left face\\r\\n \\tp1.x = p1.y = p1.z = -0.5f;\\r\\n \\tp2.x = p2.y = -0.5f;\\r\\n \\tp2.z = 0.5f;\\r\\n \\tp3.x = -0.5f;\\r\\n \\tp3.y = p3.z = 0.5f;\\r\\n \\tp4.y = 0.5f;\\r\\n \\tp4.x = p4.z = -0.5f;\\r\\n \\t\\r\\n \\th = p1.z;\\r\\n \\tv = p1.y;\\r\\n \\t\\r\\n \\t\\r\\n \\tfor( int i = 0; i <= subdivisions; i++ )\\r\\n \\t{\\r\\n \\t\\thorz[i] = h;\\r\\n \\t\\th = h + (float)(1/(float)subdivisions);\\r\\n \\t}\\r\\n \\t\\r\\n \\tfor( int i = 0; i <= subdivisions; i++)\\r\\n \\t{\\r\\n \\t\\tvert[i] = v;\\r\\n \\t\\tv = v + (float)(1/(float)subdivisions);\\r\\n \\t}\\r\\n \\t\\r\\n \\tfor( int j = 0; j < vert.length - 1; j ++)\\r\\n \\t\\tfor( int k = 0; k < horz.length - 1; k ++)\\r\\n \\t\\t{\\r\\n \\t\\t\\tPoint tempP1 = new Point(-0.5f, vert[j], horz[k]);\\r\\n \\t\\t\\tPoint tempP2 = new Point(-0.5f, vert[j], horz[k + 1]);\\r\\n \\t\\t\\tPoint tempP3 = new Point(-0.5f, vert[j + 1], horz[k + 1]);\\r\\n \\t\\t\\tPoint tempP4 = new Point(-0.5f, vert[j + 1], horz[k]);\\r\\n \\t\\t\\t\\r\\n \\t\\t\\taddTriangle(tempP1.x, tempP1.y, tempP1.z, tempP3.x, tempP3.y, tempP3.z, tempP4.x, tempP4.y, tempP4.z);\\r\\n \\t\\t\\taddTriangle(tempP1.x, tempP1.y, tempP1.z, tempP2.x, tempP2.y, tempP2.z, tempP3.x, tempP3.y, tempP3.z);\\r\\n \\t\\t\\t\\r\\n \\t\\t}\\r\\n \\t\\r\\n \\t// Right face\\r\\n \\tp1.x = p1.z = 0.5f;\\r\\n \\tp1.y = -0.5f;\\r\\n \\tp2.y = p2.z = -0.5f;\\r\\n \\tp2.x = 0.5f;\\r\\n \\tp3.x = p3.y = 0.5f;\\r\\n \\tp3.z = -0.5f;\\r\\n \\tp4.x = p4.y = p4.z = 0.5f;\\r\\n \\t\\r\\n \\t\\r\\n \\th = p1.z;\\r\\n \\tv = p1.y;\\r\\n \\t\\r\\n \\t\\r\\n \\tfor( int i = 0; i <= subdivisions; i++ )\\r\\n \\t{\\r\\n \\t\\thorz[i] = h;\\r\\n \\t\\th = h - (float)(1/(float)subdivisions);\\r\\n \\t}\\r\\n \\t\\r\\n \\tfor( int i = 0; i <= subdivisions; i++)\\r\\n \\t{\\r\\n \\t\\tvert[i] = v;\\r\\n \\t\\tv = v + (float)(1/(float)subdivisions);\\r\\n \\t}\\r\\n \\t\\r\\n \\tfor( int j = 0; j < vert.length - 1; j ++)\\r\\n \\t\\tfor( int k = 0; k < horz.length - 1; k ++)\\r\\n \\t\\t{\\r\\n \\t\\t\\tPoint tempP1 = new Point(0.5f, vert[j], horz[k]);\\r\\n \\t\\t\\tPoint tempP2 = new Point(0.5f, vert[j], horz[k + 1]);\\r\\n \\t\\t\\tPoint tempP3 = new Point(0.5f, vert[j + 1], horz[k + 1]);\\r\\n \\t\\t\\tPoint tempP4 = new Point(0.5f, vert[j + 1], horz[k]);\\r\\n \\t\\t\\t\\r\\n \\t\\t\\taddTriangle(tempP1.x, tempP1.y, tempP1.z, tempP3.x, tempP3.y, tempP3.z, tempP4.x, tempP4.y, tempP4.z);\\r\\n \\t\\t\\taddTriangle(tempP1.x, tempP1.y, tempP1.z, tempP2.x, tempP2.y, tempP2.z, tempP3.x, tempP3.y, tempP3.z);\\r\\n \\t\\t\\t\\r\\n \\t\\t}\\r\\n \\t\\r\\n \\t// Top face\\r\\n \\tp1.x = -0.5f;\\r\\n \\tp1.y = p1.z = 0.5f;\\r\\n \\tp2.x = p2.y = p2.z = 0.5f;\\r\\n \\tp3.x = p3.y = 0.5f;\\r\\n \\tp3.z = -0.5f;\\r\\n \\tp4.x = p4.z = -0.5f;\\r\\n \\tp4.y = 0.5f;\\r\\n \\t\\r\\n \\t\\r\\n \\th = p1.x;\\r\\n \\tv = p1.z;\\r\\n \\t\\r\\n \\t\\r\\n \\tfor( int i = 0; i <= subdivisions; i++ )\\r\\n \\t{\\r\\n \\t\\thorz[i] = h;\\r\\n \\t\\th = h + (float)(1/(float)subdivisions);\\r\\n \\t}\\r\\n \\t\\r\\n \\tfor( int i = 0; i <= subdivisions; i++)\\r\\n \\t{\\r\\n \\t\\tvert[i] = v;\\r\\n \\t\\tv = v - (float)(1/(float)subdivisions);\\r\\n \\t}\\r\\n \\t\\r\\n \\tfor( int j = 0; j < vert.length - 1; j ++)\\r\\n \\t\\tfor( int k = 0; k < horz.length - 1; k ++)\\r\\n \\t\\t{\\r\\n \\t\\t\\tPoint tempP1 = new Point(horz[k], 0.5f, vert[j]);\\r\\n \\t\\t\\tPoint tempP2 = new Point(horz[k + 1], 0.5f, vert[j]);\\r\\n \\t\\t\\tPoint tempP3 = new Point(horz[k + 1], 0.5f, vert[j + 1]);\\r\\n \\t\\t\\tPoint tempP4 = new Point(horz[k], 0.5f, vert[j + 1]);\\r\\n \\t\\t\\t\\r\\n \\t\\t\\taddTriangle(tempP1.x, tempP1.y, tempP1.z, tempP3.x, tempP3.y, tempP3.z, tempP4.x, tempP4.y, tempP4.z);\\r\\n \\t\\t\\taddTriangle(tempP1.x, tempP1.y, tempP1.z, tempP2.x, tempP2.y, tempP2.z, tempP3.x, tempP3.y, tempP3.z);\\r\\n \\t\\t\\t\\r\\n \\t\\t}\\r\\n \\t\\r\\n \\t// Bottom face\\r\\n \\tp1.x = p1.y = p1.z = -0.5f;\\r\\n \\tp2.y = p2.z = 0.5f;\\r\\n \\tp2.x = 0.5f;\\r\\n \\tp3.x = p3.z = 0.5f;\\r\\n \\tp3.y = -0.5f;\\r\\n \\tp4.x = p4.y = -0.5f;\\r\\n \\tp4.z = 0.5f;\\r\\n \\t\\r\\n \\t\\r\\n \\th = p1.x;\\r\\n \\tv = p1.z;\\r\\n \\t\\r\\n \\t\\r\\n \\tfor( int i = 0; i <= subdivisions; i++ )\\r\\n \\t{\\r\\n \\t\\thorz[i] = h;\\r\\n \\t\\th = h + (float)(1/(float)subdivisions);\\r\\n \\t}\\r\\n \\t\\r\\n \\tfor( int i = 0; i <= subdivisions; i++)\\r\\n \\t{\\r\\n \\t\\tvert[i] = v;\\r\\n \\t\\tv = v + (float)(1/(float)subdivisions);\\r\\n \\t}\\r\\n \\t\\r\\n \\tfor( int j = 0; j < vert.length - 1; j ++)\\r\\n \\t\\tfor( int k = 0; k < horz.length - 1; k ++)\\r\\n \\t\\t{\\r\\n \\t\\t\\tPoint tempP1 = new Point(horz[k], -0.5f, vert[j]);\\r\\n \\t\\t\\tPoint tempP2 = new Point(horz[k + 1], -0.5f, vert[j]);\\r\\n \\t\\t\\tPoint tempP3 = new Point(horz[k + 1], -0.5f, vert[j + 1]);\\r\\n \\t\\t\\tPoint tempP4 = new Point(horz[k], -0.5f, vert[j + 1]);\\r\\n \\t\\t\\t\\r\\n \\t\\t\\taddTriangle(tempP1.x, tempP1.y, tempP1.z, tempP3.x, tempP3.y, tempP3.z, tempP4.x, tempP4.y, tempP4.z);\\r\\n \\t\\t\\taddTriangle(tempP1.x, tempP1.y, tempP1.z, tempP2.x, tempP2.y, tempP2.z, tempP3.x, tempP3.y, tempP3.z);\\r\\n \\t\\t\\t\\r\\n \\t\\t}\\r\\n \\t\\r\\n }\",\n \"@Override\\r\\n protected void initModel() {\\n model = new Sphere(\\\"projectil Model\\\", 5, 5, 0.2f);\\r\\n model.setModelBound(new BoundingBox());\\r\\n model.updateModelBound();\\r\\n }\",\n \"private void generateCube() {\\n\\t\\tverts = new Vector[] {new Vector(3), new Vector(3), new Vector(3), new Vector(3), new Vector(3), new Vector(3), new Vector(3), new Vector(3)};\\n\\t\\tverts[0].setElement(0, -1);\\n\\t\\tverts[0].setElement(1, -1);\\n\\t\\tverts[0].setElement(2, -1);\\n\\t\\t\\n\\t\\tverts[1].setElement(0, 1);\\n\\t\\tverts[1].setElement(1, -1);\\n\\t\\tverts[1].setElement(2, -1);\\n\\t\\t\\n\\t\\tverts[2].setElement(0, -1);\\n\\t\\tverts[2].setElement(1, -1);\\n\\t\\tverts[2].setElement(2, 1);\\n\\t\\t\\n\\t\\tverts[3].setElement(0, 1);\\n\\t\\tverts[3].setElement(1, -1);\\n\\t\\tverts[3].setElement(2, 1);\\n\\t\\t\\n\\t\\tverts[4].setElement(0, -1);\\n\\t\\tverts[4].setElement(1, 1);\\n\\t\\tverts[4].setElement(2, -1);\\n\\t\\t\\n\\t\\tverts[5].setElement(0, 1);\\n\\t\\tverts[5].setElement(1, 1);\\n\\t\\tverts[5].setElement(2, -1);\\n\\t\\t\\n\\t\\tverts[6].setElement(0, -1);\\n\\t\\tverts[6].setElement(1, 1);\\n\\t\\tverts[6].setElement(2, 1);\\n\\t\\t\\n\\t\\tverts[7].setElement(0, 1);\\n\\t\\tverts[7].setElement(1, 1);\\n\\t\\tverts[7].setElement(2, 1);\\n\\t\\t\\n\\t\\tfaces = new int[][] {{0, 3, 2}, {0, 1, 3}, {0, 4, 5}, {0, 5, 1}, {0, 2, 6}, {0, 6, 4}, {2, 7, 6}, {2, 3, 7}, {3, 1, 5}, {3, 5, 7}, {4, 7, 5}, {4, 6, 7}}; // List the vertices of each face by index in verts. Vertices must be listed in clockwise order from outside of the shape so that the faces pointing away from the camera can be culled or shaded differently\\n\\t}\",\n \"public Point sphereCoords(double r, double phi, double theta) {\\n\\t\\t\\n\\t\\tx = r*Math.sin(phi)*Math.cos(theta);\\n\\t\\ty = r*Math.sin(phi)*Math.sin(theta);\\n\\t\\tz = r*Math.cos(phi);\\n\\t\\treturn this;\\n\\t}\",\n \"public void makeCone (float radius, int radialDivisions, int heightDivisions)\\r\\n {\\r\\n \\tPoint lower[][] = new Point[heightDivisions + 1][radialDivisions + 1];\\r\\n \\t\\r\\n \\tfloat rad[] = new float[heightDivisions + 1];\\r\\n \\tfloat vert = -0.5f;\\r\\n \\t\\r\\n \\t// Calculate radius for every subdivision along the height\\r\\n \\tfor(int i = 0; i < heightDivisions; i ++)\\r\\n \\t{\\r\\n \\t\\trad[i] = radius * ( 1.0f - ( 1f /(float)heightDivisions) * i );\\r\\n \\t}\\r\\n \\t\\r\\n \\t// Calculate curved surface vertices for every subdivision along the height\\r\\n \\tfor(int i = 0; i <= heightDivisions; i ++ )\\r\\n \\t{\\r\\n \\t\\tfor(int j = 0; j <= radialDivisions; j ++)\\r\\n \\t\\t{\\r\\n \\t\\t\\tlower[i][j] = new Point();\\r\\n \\t\\t\\tlower[i][j].x = rad[i] * (float)Math.cos(Math.toRadians ( (360.0f / (float)radialDivisions) * j ) );\\r\\n \\t\\t\\tlower[i][j].z = rad[i] * (float)Math.sin(Math.toRadians ( (360.0f / (float)radialDivisions) * j ) );\\r\\n \\t\\t\\tlower[i][j].y = vert;\\r\\n \\t\\t}\\r\\n \\t\\t// Update the y coordinate for next iteration\\r\\n \\t\\tvert += (1f / (float)heightDivisions);\\r\\n \\t}\\r\\n \\t\\r\\n \\tvert = -0.5f;\\r\\n \\t\\r\\n \\t// Print the bottom circular surface\\r\\n \\tfor(int i = 0; i <= radialDivisions - 1; i ++)\\r\\n \\t{\\r\\n \\t\\tthis.addTriangle(lower[0][i].x, vert, lower[0][i].z, 0f, vert, 0f, lower[0][i+1].x, vert, lower[0][i+1].z );\\r\\n \\t}\\r\\n \\t\\r\\n \\t// Print the curved surface\\r\\n \\tfor(int i = 0 ; i < heightDivisions; i++)\\r\\n \\t\\tfor(int j = 0 ; j < radialDivisions; j++)\\r\\n \\t\\t{\\r\\n \\t\\t\\tthis.addTriangle(lower[i][j].x, lower[i][j].y, lower[i][j].z, lower[i][j+1].x, lower[i][j+1].y, lower[i][j+1].z, lower[i+1][j+1].x, lower[i+1][j+1].y, lower[i+1][j+1].z);\\r\\n \\t\\t\\tthis.addTriangle(lower[i][j].x, lower[i][j].y, lower[i][j].z, lower[i+1][j+1].x, lower[i+1][j+1].y, lower[i+1][j+1].z, lower[i+1][j].x, lower[i+1][j].y, lower[i+1][j].z);\\r\\n \\t\\t\\t\\r\\n \\t\\t}\\r\\n }\",\n \"public static void main(String[] args){\\n Mesh3D box = Mesh3D.box(10, 20, 60);\\n \\n Line3D lineX = box.getLineX();\\n Line3D lineY = box.getLineY();\\n Line3D lineZ = box.getLineZ();\\n lineX.show();\\n lineY.show();\\n lineZ.show();\\n box.translateXYZ(100, 0.0, 0.0); \\n box.show();\\n Line3D line = new Line3D(); \\n List intersects = new ArrayList();\\n \\n for(int p = 0; p < 100; p++){\\n double r = 600;\\n double theta = Math.toRadians(90.0);//Math.toRadians(Math.random()*180.0);\\n double phi = Math.toRadians(Math.random()*360.0-180.0);\\n line.set(0.0,0.0,0.0, \\n Math.sin(theta)*Math.cos(phi)*r,\\n Math.sin(theta)*Math.sin(phi)*r,\\n Math.cos(theta)*r\\n );\\n intersects.clear();\\n box.intersectionRay(line, intersects);\\n System.out.println(\\\"theta/phi = \\\" + Math.toDegrees(theta) + \\\" \\\"\\n + Math.toDegrees(phi) + \\\" intersects = \\\" + intersects.size());\\n \\n }\\n }\",\n \"public Spherical toSpherical() {\\n\\t\\tdouble rho = Math.sqrt(Math.pow(x, 2) + Math.pow(y, 2) + Math.pow(z, 2));\\n\\t\\t// z = rho cos(phi), phi = arccos(z / rho)\\n\\t\\tdouble phi = Math.acos(z / rho);\\n\\t\\t// r^2 = x^2 + y^2, r = sqrt(x^2 + y^2)\\n\\t\\t// x = r cos(theta), theta = arccos(x / r)\\n\\t\\tdouble r = xyToR(x, y);\\n\\t\\tdouble theta = Math.acos(x / r);\\n\\t\\treturn new Spherical(rho, theta, phi);\\n\\t}\",\n \"public DiscMesh(float radius, int numVertices) {\\n Validate.nonNegative(radius, \\\"radius\\\");\\n Validate.inRange(\\n numVertices, \\\"number of vertices\\\", 3, Integer.MAX_VALUE);\\n\\n setMode(Mode.TriangleFan);\\n\\n float[] normals = new float[numAxes * numVertices];\\n float[] positions = new float[numAxes * numVertices];\\n float[] texCoords = new float[2 * numVertices];\\n\\n for (int vi = 0; vi < numVertices; ++vi) {\\n normals[numAxes * vi] = 0f;\\n normals[numAxes * vi + 1] = 0f;\\n normals[numAxes * vi + 2] = 1f;\\n\\n float theta = FastMath.TWO_PI * vi / numVertices;\\n float sin = FastMath.sin(theta);\\n float cos = FastMath.cos(theta);\\n positions[numAxes * vi] = radius * cos;\\n positions[numAxes * vi + 1] = radius * sin;\\n positions[numAxes * vi + 2] = 0f;\\n\\n texCoords[2 * vi] = (1f + cos) / 2f;\\n texCoords[2 * vi + 1] = (1f + sin) / 2f;\\n }\\n\\n setBuffer(Type.Normal, numAxes, normals);\\n setBuffer(Type.Position, numAxes, positions);\\n setBuffer(Type.TexCoord, 2, texCoords);\\n\\n updateBound();\\n setStatic();\\n }\",\n \"public Sphere(Point3D c, double r, Color color, Material material)\\r\\n\\t{\\r\\n\\t\\tthis(c,r, color);\\r\\n\\t\\tsuper._material = material;\\r\\n\\t}\",\n \"public static double squareToUniformSpherePdf(Tuple3d v) {\\n // TODO: Fill in this method.\\n return 0;\\n }\",\n \"public Vector3f getSphereCenter() {\\n\\t\\tfloat[] arr = getMinMax();\\n\\t\\t\\n\\t\\treturn new Vector3f((arr[0]+arr[1])/2,(arr[2]+arr[3])/2,(arr[4]+arr[5])/2);\\n\\t}\",\n \"public static double sphereArea(double radius) {\\r\\n return 4 * Math.PI * radius * radius;\\r\\n }\",\n \"private void generatePrism() {\\n\\t\\tdouble halfAltitude = Math.sin(Math.PI / 3); // The cross-section is an equilateral triangle with sides of length 2 units. The altitude is the height of the triangle with one edge horizontal\\n\\t\\tverts = new Vector[] {new Vector(3), new Vector(3), new Vector(3), new Vector(3), new Vector(3), new Vector(3)};\\n\\t\\tverts[0].setElements(new double[] {-1, -halfAltitude, -1});\\n\\t\\tverts[1].setElements(new double[] {0, halfAltitude, -1});\\n\\t\\tverts[2].setElements(new double[] {1, -halfAltitude, -1});\\n\\t\\t// Use the same triangle of vertices but offset by 2 units along the z-axis\\n\\t\\tverts[3].setElements(verts[0]);\\n\\t\\tverts[4].setElements(verts[1]);\\n\\t\\tverts[5].setElements(verts[2]);\\n\\t\\tverts[3].setElement(2, 1);\\n\\t\\tverts[4].setElement(2, 1);\\n\\t\\tverts[5].setElement(2, 1);\\n\\t\\t\\n\\t\\tfaces = new int[][] {{0, 1, 2}, {0, 5, 3}, {0, 2, 5}, {0, 3, 4}, {0, 4, 1}, {1, 4, 5}, {1, 5, 2}, {3, 5, 4}};\\n\\t}\",\n \"public float getSphereRadius() {\\n\\t\\treturn sphereRadius;\\n\\t}\",\n \"Obj(double x1, double y1, double z1, double x2, double y2, double z2, double x3, double y3, double z3){\\t// CAMBIAR LAS COORDENADAS X,Y,Z CON 0,1 PARA CONSTRUIR PRISMA, CILINDRO, PIRAMIDE, CONO Y ESFERA.\\n w\\t= new Point3D[4];\\n\\tvScr\\t= new Point2D[4];\\n \\n w[0]\\t= new Point3D(0, 0, 0); // desde la base\\n\\tw[1]\\t= new Point3D(x1, y1, z1);\\n\\tw[2]\\t= new Point3D(x2, y2, z2);\\n\\tw[3]\\t= new Point3D(x3, y3, z3);\\n \\n\\tobjSize = (float) Math.sqrt(12F); \\n rho\\t= 5 * objSize;\\n }\",\n \"@Override\\r\\n public Shape createShape(RenderContext ctx) {\\n float v[] = { -1, -1, 1, 1, -1, 1, 1, 1, 1, -1, 1, 1, // front face\\r\\n -1, -1, -1, -1, -1, 1, -1, 1, 1, -1, 1, -1, // left face\\r\\n -1, -1, 1, -1, -1, -1, 1, -1, -1, 1, -1, 1 }; // bottom face\\r\\n\\r\\n // The vertex normals\\r\\n float n[] = { 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, // front face\\r\\n -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, // left face\\r\\n 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0 }; // bottom face\\r\\n\\r\\n // The vertex colors\\r\\n float c[] = { 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, //\\r\\n 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, //\\r\\n 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1 };\\r\\n\\r\\n // Texture coordinates\\r\\n float uv[] = { 0, 0, 1, 0, 1, 1, 0, 1, //\\r\\n 0, 0, 1, 0, 1, 1, 0, 1, //\\r\\n 0, 0, 1, 0, 1, 1, 0, 1 };\\r\\n\\r\\n // The triangles (three vertex indices for each triangle)\\r\\n int indices[] = { 0, 2, 3, 0, 1, 2, // front face\\r\\n 4, 6, 7, 4, 5, 6, // left face\\r\\n 8, 10, 11, 8, 9, 10 }; // bottom face\\r\\n\\r\\n // Construct a data structure that stores the vertices, their\\r\\n // attributes, and the triangle mesh connectivity\\r\\n VertexData vertexData = ctx.makeVertexData(12);\\r\\n vertexData.addElement(c, VertexData.Semantic.COLOR, 3);\\r\\n vertexData.addElement(v, VertexData.Semantic.POSITION, 3);\\r\\n vertexData.addElement(n, VertexData.Semantic.NORMAL, 3);\\r\\n vertexData.addElement(uv, VertexData.Semantic.TEXCOORD, 2);\\r\\n vertexData.addIndices(indices);\\r\\n\\r\\n return new jrtr.Shape(vertexData);\\r\\n }\",\n \"private void addTestListData() {\\n\\t\\ts.add(new Sphere(quad, sky, 1000, 0, 0, 0, -90, 0, 0));\\n\\t\\t\\n//\\t\\ts.add(new Sphere(quad, planets[0], 3.8f, 50, 40, -50, -90, 0, 0));\\n//\\t\\ts.add(new Sphere(quad, planets[1], 9.5f, 40, 40, -20, -90, 0, 0));\\n//\\t\\ts.add(new Sphere(quad, planets[2], 10.f, 0, 40, -20, -90, 0, 0));\\n//\\t\\ts.add(new Sphere(quad, planets[3], 5.3f,-20, 40, -50, -90, 0, 0));\\n//\\t\\t\\n//\\t\\ts.add(new Sphere(quad, planets[4], 112f, 410, 120, 100, -90, 0, 0));\\n//\\t\\ts.add(new Sphere(quad, planets[5], 94.5f, 100, 120, 260, -90, 0, 0));\\n//\\t\\ts.add(new Sphere(quad, planets[6], 40f, -170, 100, 240, -90, 0, 0));\\n//\\t\\ts.add(new Sphere(quad, planets[7], 38.8f, -270, 100, 200, -90, 0, 0));\\n//\\t\\t\\n//\\t\\ts.add(new Sphere(quad, planets[8], 5, -110, 50, 50, -90, 0, 0));\\n//\\t\\ts.add(new Sphere(quad, planets[9], 2.5f, 0, 40, -40, -90, 0, 0));\\n//\\t\\t\\n//\\t\\ts.add(new Disc(quad, ring, 225, 100, 120, 260, -90, 0, 0));\\n\\t\\t\\n\\t\\tms.add(new ModelShape(models[2], 12, 6, 12, 0, 0, 0, 0, 0, 0));\\n//\\t\\tms.add(new ModelShape(models[3], 1, 1, 1, -50, 15, -50, 0, 0, 0));\\n//\\t\\tms.add(new ModelShape(models[4], 1, 1, 1, 0, 15, -70, 0, 0, 0));\\n//\\t\\tms.add(new ModelShape(models[5], 1, 1, 1, 0, 15, -70, 0, 0, 0));\\n//\\t\\tms.add(new ModelShape(models[6], 1, 1, 1, 0, 15, -70, 0, 0, 0));\\n//\\t\\tms.add(new ModelShape(models[7], 1, 1, 1, 0, 15, -70, 0, 0, 0));\\n//\\t\\tms.add(new ModelShape(models[8], 3, 3, 3, 0, 20, -45, 0, 0, 0));\\n//\\t\\tms.add(new ModelShape(models[9], 1, 1, 1, 30, 15, -40, 0, 0, 0));\\n\\t\\t//ms.add(new ModelShape(models[10], 0.2f, 0.2f, 0.2f, 0, -30, -40, 0, 0, 0));\\n\\t}\",\n \"public Polygon getPolygon(double eyeDistance){\\n //define the front two verticies of the currentTrack\\n Point3D track_vertex0 = currentTrack.getVertex(0);\\n Point3D track_vertex1 = currentTrack.getVertex(1);\\n //use center point to define the center of the sphape\\n int cubeSize = 3;\\n\\n Point3D front_up_left = new Point3D (centerPoint.x-cubeSize, centerPoint.y-cubeSize, centerPoint.z-cubeSize);\\n Point3D front_down_left = new Point3D (centerPoint.x-cubeSize, centerPoint.y+cubeSize, centerPoint.z-cubeSize);\\n Point3D front_down_right = new Point3D (centerPoint.x+cubeSize, centerPoint.y+cubeSize, centerPoint.z-cubeSize);\\n Point3D front_up_right = new Point3D (centerPoint.x+cubeSize, centerPoint.y-cubeSize, centerPoint.z-cubeSize);\\n\\n Point3D back_up_left = new Point3D (front_up_left.x, front_up_left.y, centerPoint.z+cubeSize);\\n Point3D back_down_left = new Point3D (front_down_left.x, front_down_left.y, centerPoint.z+cubeSize);\\n Point3D back_down_right = new Point3D (front_down_right.x, front_down_right.y, centerPoint.z+cubeSize);\\n Point3D back_up_right = new Point3D (front_up_right.x, front_up_right.y, centerPoint.z+cubeSize);\\n\\n //aranges verticies in the order they will be drawn\\n Point3D[] cube_verticies = {front_up_left, front_down_left, front_down_right, front_up_right,\\n front_up_left, back_up_left, back_up_right, front_up_right,\\n front_down_right, back_down_right, back_up_right, back_down_right,\\n back_down_left, back_up_left, back_down_left, front_down_left};\\n\\n int[] x_points = new int[16];\\n int[] y_points = new int[16];\\n //convert 3D points to 2D points\\n for(int i=0;i<16;i++){\\n if(cube_verticies[i].z <= 200){ //same fix as for the track positioning\\n x_points[i] = (int) -cube_verticies[i].projectPoint3D(eyeDistance).getX();\\n y_points[i] = (int) cube_verticies[i].projectPoint3D(eyeDistance).getY();\\n }\\n else{\\n x_points[i] = (int) cube_verticies[i].projectPoint3D(eyeDistance).getX();\\n y_points[i] = (int) cube_verticies[i].projectPoint3D(eyeDistance).getY();\\n }\\n }\\n Polygon polygon = new Polygon(x_points, y_points, 16);\\n return polygon;\\n }\",\n \"public Prism(int numSides, double radius, double height) {\\n Vector3d toTop = new Vector3d(0.0, 0.0, height);\\n double centralAngle = 2.0 * Math.PI / numSides;\\n\\n Face bottomFace = new Face(numSides);\\n Face topFace = new Face(numSides);\\n int vertexIndex = 0;\\n for (int i = 0; i < numSides; i++) {\\n double totalAngle = centralAngle * i;\\n double x = radius * Math.cos(totalAngle);\\n double y = radius * Math.sin(totalAngle);\\n Vector3d bottomVertex = new Vector3d(x, y, -height / 2.0);\\n\\n Vector3d topVertex = new Vector3d();\\n topVertex.add(bottomVertex, toTop);\\n\\n addVertexPositions(bottomVertex, topVertex);\\n\\n bottomFace.setVertexIndex(numSides - i - 1, vertexIndex);\\n topFace.setVertexIndex(i, vertexIndex + 1);\\n\\n Face quad = new Face(4);\\n int nextBottom = (vertexIndex + 2) % (2 * numSides);\\n int nextTop = nextBottom + 1;\\n quad.setAllVertexIndices(vertexIndex, nextBottom, nextTop,\\n vertexIndex + 1);\\n\\n addFace(quad);\\n\\n vertexIndex += 2;\\n }\\n\\n addFaces(bottomFace, topFace);\\n\\n setVertexNormalsToFaceNormals();\\n }\",\n \"@Test\\n public void bonusTMoveCamera2() {\\n Scene scene = new Scene(\\\"Test scene\\\");\\n scene.setCamera(new Camera(new Point3D(3100, -3100, -2600), new Vector(-2, 2, 2), new Vector(-1, -2, 1)));\\n scene.setDistance(600);\\n scene.setBackground(Color.BLACK);\\n scene.setAmbientLight(new AmbientLight(new Color(java.awt.Color.WHITE), 0.15));\\n\\n scene.addGeometries( //\\n new Plane(new Material(0.4, 0.1, 60, 0, 0), new Color(java.awt.Color.DARK_GRAY),\\n new Point3D(0, 400, 100), new Vector(0, -1, 0)),\\n new Polygon(Color.BLACK, new Material(0.2, 0.3, 200, 0.5, 0),\\n new Point3D(-1, -300, 500), new Point3D(-1, -140, 500), new Point3D(1, -140, 500), new Point3D(1, -300, 500)),\\n new Sphere(new Color(java.awt.Color.yellow), new Material(0.2, 0.2, 200, 0, 0.6), // )\\n 80, new Point3D(-1, -120, 500)),\\n new Polygon(Color.BLACK, new Material(0.2, 0.2, 200, 0.9, 0),\\n new Point3D(-150, -150, 1999), new Point3D(-150, 200, 1999), new Point3D(150, 200, 1999), new Point3D(150, -150, 1999)),\\n new Sphere(new Color(800, 0, 0), new Material(0.3, 0.5, 200, 0.2, 0), // )\\n 140, new Point3D(300, 260, 600)),\\n new Sphere(new Color(0, 0, 200), new Material(0.25, 0.25, 20, 0, 0.25), // )\\n 140, new Point3D(-260, 260, 0)),\\n new Sphere(new Color(400, 20, 20), new Material(0.2, 0.5, 200, 0, 0.3), // )\\n 100, new Point3D(-600, 300, 1300)),\\n new Triangle(new Color(100, 300, 100), new Material(0.25, 0.5, 100, 0.25, 0),\\n new Point3D(-100, 400, 150), new Point3D(100, 400, 350), new Point3D(0, 200, 250)));\\n\\n scene.addLights(new SpotLight(new Color(700, 400, 400), //no. 1\\n new Point3D(0, 0, -1500), 1, 4E-5, 2E-7, new Vector(0, 0, 1)).setRadius(15),\\n new PointLight(new Color(200, 400, 200), new Point3D(0.001, -100, 499), 1, 4E-5, 2E-7).setRadius(15),//no.2\\n new PointLight(new Color(200, 200, 400), new Point3D(0.001, -50, 1000), 1, 4E-5, 2E-7).setRadius(25));//no.3\\n\\n ImageWriter imageWriter = new ImageWriter(\\\"The magical room moving camera to right - soft shadow 5\\\", 200, 200, 1000, 1000);\\n Render render = new Render(imageWriter, scene).setSuperSampling(400).setMultithreading(3).setDebugPrint();\\n\\n render.renderImage();\\n render.writeToImage();\\n }\",\n \"private void generateHalfCylinder() {\\n\\t\\tint segments = 32;\\n\\t\\tverts = new Vector[segments * 2];\\n\\t\\tfaces = new int[4 * segments - 4][3];\\n\\t\\tdouble heading = 0;\\n\\t\\tdouble headingIncrement = Math.PI / (segments - 1); // The increment in heading between segments of vertices\\n\\t\\tfor (int s = 0; s < segments; s++) {\\n\\t\\t\\tdouble x = Math.cos(heading); // x co-ordinate of points on the segment\\n\\t\\t\\tdouble z = Math.sin(heading); // z co-ordinate of points on the segment\\n\\t\\t\\tverts[s] = new Vector(3);\\n\\t\\t\\tverts[s].setElements(new double[] {x, -1, z}); // Vertex on the bottom semi-circle\\n\\t\\t\\tverts[s + segments] = new Vector(3);\\n\\t\\t\\tverts[s + segments].setElements(new double[] {x, 1, z}); // Vertex on the top semi-circle\\n\\t\\t\\theading += headingIncrement;\\n\\t\\t}\\n\\t\\tfor (int i = 0; i < segments - 1; i++) { // Vertical faces approximating the curved surface\\n\\t\\t\\tfaces[i * 2] = new int[] {i, i + segments, i + segments + 1}; // Face involving a point on the bottom semi-circle, the point directly above it (top semi-circle and the same segment) and the point directly above and one segment across\\n\\t\\t\\tfaces[i * 2 + 1] = new int[] {i, i + segments + 1, i + 1}; // Face involving a point on the bottom semi-circle, the point above and one segment across and the point one segment across on the bottom semi-circle\\n\\t\\t}\\n\\t\\tfor (int i = 0; i < segments - 2; i++) { // Horizontal faces approximating the semi-circles at the top and bottom\\n\\t\\t\\tfaces[segments * 2 - 2 + i] = new int[] {0, i + 1, i + 2}; // For the bottom semi-circle, the first vertex connected to the (i + 1)th vertex and the (i + 2)th vertex\\n\\t\\t\\tfaces[segments * 2 - 2 + i + segments - 2] = new int[] {segments, segments + i + 2, segments + i + 1}; // The same as above but for the top semi-circle\\n\\t\\t}\\n\\t\\t// Faces representing the vertical square cross-section\\n\\t\\tfaces[4 * segments - 6] = new int[] {0, segments * 2 - 1, segments}; // The first vertex, the last vertex and the one above the first\\n\\t\\tfaces[4 * segments - 5] = new int[] {0, segments - 1, segments * 2 - 1}; // The first vertex, the last vertex on the bottom and the last vertex (on the top)\\n\\t}\",\n \"@Override\\n protected void createMesh() {\\n rayLight.getScope().add(camera);\\n\\n light = new PointLight(Color.GAINSBORO);\\n light.setTranslateX(-300);\\n light.setTranslateY(300);\\n light.setTranslateZ(-2000);\\n\\n light2 = new PointLight(Color.ALICEBLUE);\\n light2.setTranslateX(300);\\n light2.setTranslateY(-300);\\n light2.setTranslateZ(2000);\\n\\n light3 = new PointLight(Color.SPRINGGREEN);\\n light3.setTranslateY(-2000);\\n //create a target\\n target1 = new Sphere(180);\\n target1.setId(\\\"t1\\\");\\n target1.setDrawMode(DrawMode.LINE);\\n target1.setCullFace(CullFace.NONE);\\n target1.setTranslateX(500);\\n target1.setTranslateY(500);\\n target1.setTranslateZ(500);\\n target1.setMaterial(red);\\n // create another target\\n target2 = new Sphere(150);\\n target2.setId(\\\"t2\\\");\\n target2.setDrawMode(DrawMode.LINE);\\n target2.setCullFace(CullFace.NONE);\\n target2.setTranslateX(-500);\\n target2.setTranslateY(-500);\\n target2.setTranslateZ(-500);\\n target2.setMaterial(blue);\\n\\n origin = new Box(20, 20, 20);\\n origin.setDrawMode(DrawMode.LINE);\\n origin.setCullFace(CullFace.NONE);\\n \\n model = new Group(target1, target2, origin, light, light2, light3, rayLight);\\n }\",\n \"RedSphere() {\\n Random random = new Random();\\n for (int i = 0; i < 6; i++) {\\n value[i] = random.nextInt(33) + 1;\\n }\\n }\",\n \"private void initMesh() {\\n\\t\\tfloat[] vertices = { -1, -1, 0, 1, -1, 0, -1, 1, 0, 1, 1, 0 };\\n\\t\\tfloat[] texCoords = { 0, 0, 1, 0, 0, 1, 1, 1 };\\n\\t\\tint[] indices = { 0, 1, 2, 3 };\\n\\t\\tmesh = new StaticMesh(gl, vertices, null, texCoords, indices);\\n\\t\\tmesh.setPositionIndex(shader.getAttributeLocation(\\\"aVertexPosition\\\"));\\n\\t\\tmesh.setNormalIndex(-1);\\n\\t\\tmesh.setTexCoordIndex(shader.getAttributeLocation(\\\"aTextureCoord\\\"));\\n\\t\\tmesh.setBeginMode(BeginMode.TRIANGLE_STRIP);\\n\\t}\",\n \"public Mesh() {\\r\\n \\tthis.surfaceAreaMethods.add(Object3D.MESH_SA);\\r\\n \\tthis.volumeMethods.add(Object3D.MESH_VOL);\\r\\n \\t\\r\\n vertices = new ArrayList();\\r\\n tris = new ArrayList();\\r\\n }\",\n \"public static double squareToUniformHemispherePdf(Tuple3d v) {\\n // TODO: Fill in this method.\\n return 0;\\n }\",\n \"private static void addTriangle(Hull3f sphere, Point3f p1, Point3f p2,\\n Point3f p3, float resolution) {\\n if ((p1.distance(p2) < resolution) || (p2.distance(p3) < resolution) || (p3.distance(p1) < resolution)) {\\n Triangle3f t;\\n t = new Triangle3f(p1, p2, p3);\\n sphere.getTriangles().add(t);\\n } else {\\n Point3f p12;\\n p12 = new Point3f(p1);\\n p12.add(p2);\\n Point3fLogic.normalize(p12);\\n Point3f p23;\\n p23 = new Point3f(p2);\\n p23.add(p3);\\n Point3fLogic.normalize(p23);\\n Point3f p31;\\n p31 = new Point3f(p3);\\n p31.add(p1);\\n Point3fLogic.normalize(p31);\\n addTriangle(sphere, p1, p12, p31, resolution);\\n addTriangle(sphere, p2, p23, p12, resolution);\\n addTriangle(sphere, p3, p31, p23, resolution);\\n addTriangle(sphere, p12, p23, p31, resolution);\\n }\\n }\",\n \"Spherical(final ParameterValueGroup parameters, final ParameterDescriptorGroup descriptor)\\r\\n throws ParameterNotFoundException\\r\\n {\\r\\n super(parameters, descriptor);\\r\\n ensureSpherical();\\r\\n }\",\n \"public static Scene scene3() {\\n\\t\\tScene finalScene = new Scene().initAmbient(new Vec(1.0))\\r\\n\\t\\t\\t\\t.initCamera(/* Camera Position = */new Point(0.0, 2.0, 6.0), \\r\\n\\t\\t\\t\\t\\t\\t/* Towards Vector = */ new Vec(0.0, -0.1 ,-1.0),\\r\\n\\t\\t\\t\\t\\t\\t/* Up vector = */new Vec(0.0, 1.0, 0.0), \\r\\n\\t\\t\\t\\t\\t\\t/*Distance to plain =*/ 2.0)\\r\\n\\t\\t\\t\\t.initName(\\\"scene3\\\").initAntiAliasingFactor(1)\\r\\n\\t\\t\\t\\t.initRenderRefarctions(true).initRenderReflections(true).initMaxRecursionLevel(6);\\r\\n // Add Surfaces to the scene.\\r\\n\\t\\t// (1) A plain that represents the ground floor.\\r\\n\\t\\tShape plainShape = new Plain(new Vec(0.0,1.0,0.0), new Point(0.0, -1.0, 0.0));\\r\\n\\t\\tMaterial plainMat = Material.getMetalMaterial();\\r\\n\\t\\tSurface plainSurface = new Surface(plainShape, plainMat);\\r\\n\\t\\tfinalScene.addSurface(plainSurface);\\r\\n\\t\\t\\r\\n\\t\\t// (2) We will also add spheres to form a triangle shape (similar to a pool game). \\r\\n\\t\\tfor (int depth = 0; depth < 4; depth++) {\\r\\n\\t\\t\\tfor(int width=-1*depth; width<=depth; width++) {\\r\\n\\t\\t\\t\\tShape sphereShape = new Sphere(new Point((double)width, 0.0, -1.0*(double)depth), 0.5);\\r\\n\\t\\t\\t\\tMaterial sphereMat = Material.getRandomMaterial();\\r\\n\\t\\t\\t\\tSurface sphereSurface = new Surface(sphereShape, sphereMat);\\r\\n\\t\\t\\t\\tfinalScene.addSurface(sphereSurface);\\r\\n\\t\\t\\t}\\r\\n\\t\\t\\t\\r\\n\\t\\t}\\r\\n\\t\\t\\r\\n\\t\\t// Add light sources:\\r\\n\\t\\tCutoffSpotlight cutoffSpotlight = new CutoffSpotlight(new Vec(0.0, -1.0, 0.0), 45.0);\\r\\n\\t\\tcutoffSpotlight.initPosition(new Point(4.0, 4.0, -3.0));\\r\\n\\t\\tcutoffSpotlight.initIntensity(new Vec(1.0,0.6,0.6));\\r\\n\\t\\tfinalScene.addLightSource(cutoffSpotlight);\\r\\n\\t\\tcutoffSpotlight = new CutoffSpotlight(new Vec(0.0, -1.0, 0.0), 30.0);\\r\\n\\t\\tcutoffSpotlight.initPosition(new Point(-4.0, 4.0, -3.0));\\r\\n\\t\\tcutoffSpotlight.initIntensity(new Vec(0.6,1.0,0.6));\\r\\n\\t\\tfinalScene.addLightSource(cutoffSpotlight);\\r\\n\\t\\tcutoffSpotlight = new CutoffSpotlight(new Vec(0.0, -1.0, 0.0), 30.0);\\r\\n\\t\\tcutoffSpotlight.initPosition(new Point(0.0, 4.0, 0.0));\\r\\n\\t\\tcutoffSpotlight.initIntensity(new Vec(0.6,0.6,1.0));\\r\\n\\t\\tfinalScene.addLightSource(cutoffSpotlight);\\r\\n\\t\\tDirectionalLight directionalLight=new DirectionalLight(new Vec(0.5,-0.5,0.0),new Vec(0.2));\\r\\n\\t\\tfinalScene.addLightSource(directionalLight);\\r\\n\\t\\t\\r\\n\\t\\treturn finalScene;\\r\\n\\t}\",\n \"public static WritableImage mapToSphere(WritableImage img) {\\n\\t\\tWritableImage result = new WritableImage((int)img.getWidth(), (int)img.getHeight());\\n\\t\\tPixelWriter writer = result.getPixelWriter();\\n\\t\\tPixelReader pixels = img.getPixelReader();\\n\\t\\t\\n\\t\\tfor (int y = 0; y < result.getHeight(); y ++) {\\n\\t\\t\\tfor (int x = 0; x < result.getWidth(); x++) {\\n\\t\\t\\t\\tdouble xT = MathUtils.map(x, 0.0, img.getWidth() - 1, 0.0, 1.0);\\n\\t\\t\\t\\tdouble yT = MathUtils.map(y, 0.0, img.getHeight() - 1, 0.0, 1.0);\\n\\t\\t\\t\\tdouble u = (int)(xT/(xT*xT + yT*yT + 1));\\n\\t\\t\\t\\tdouble v = (int)(yT/(xT*xT + yT*yT + 1));\\n\\t\\t\\t\\t\\n\\t\\t\\t\\tSystem.out.println(\\\"\\\" + u + \\\", \\\" + v);\\n\\t\\t\\t\\t\\n\\t\\t\\t\\tint fromX = (int)(u*(img.getWidth() - 1));\\n\\t\\t\\t\\tint fromY = (int)(v*(img.getHeight() - 1));\\n\\t\\t\\t\\twriter.setColor(x, y, pixels.getColor(fromX, fromY));\\n\\t\\t\\t}\\n\\t\\t}\\n\\t\\t\\n\\t\\treturn result;\\n\\t}\",\n \"@Override\\n protected void interpolate(double frac) {\\n ray.project(dist * frac);\\n // set the sphere to ray position\\n s.setTranslateX(ray.getPosition().getX());\\n s.setTranslateY(ray.getPosition().getY());\\n s.setTranslateZ(ray.getPosition().getZ());\\n\\n }\",\n \"public static double squareToCosineHemispherePdf(Tuple3d v) {\\n // TODO: Fill in this method.\\n return 0;\\n }\",\n \"@Override\\n\\tpublic BoundingSphereTree getBoundingSpheres() {\\n\\t\\tthis.boundingSphere.setSphereColore3d(1,0,0);\\n\\t\\tboundingSphereTree.setBoundingSphere(this.boundingSphere);\\n\\t\\tboundingSphereTree.getList().add(wheels.getlWheel().getBoundingSphereTree());\\n\\t\\tboundingSphereTree.getList().add(wheels.getrWheel().getBoundingSphereTree());\\n\\t\\treturn boundingSphereTree;\\n\\t}\",\n \"public void testCreateMeshFactory() {\\r\\n SXRContext sxrContext = TestDefaultSXRViewManager.mSXRContext;\\r\\n assertNotNull(sxrContext.createQuad(11, 22));\\r\\n }\",\n \"@Override\\n public void start(Stage primaryStage) throws Exception {\\n PerspectiveCamera camera = new PerspectiveCamera(true);\\n camera.setTranslateZ(-10000);\\n camera.setNearClip(0.1);\\n camera.setFarClip(100000.0);\\n\\n //Creates group that holds sphere\\n Group group = new Group();\\n //Create subscene that holds group\\n SubScene world = new SubScene(group, 3.0 * WIDTH / 4.0, HEIGHT, true, SceneAntialiasing.DISABLED);\\n\\n //Container for controls\\n VBox controls = new VBox(10);\\n controls.setAlignment(Pos.TOP_CENTER);\\n controls.setPadding(new Insets(10, 0, 0, 0));\\n\\n //Slider that changes G value\\n Label gLabel = new Label(\\\"Gravitational Constant\\\");\\n Slider gConstant = new Slider(.001, 100000, 6.67408 * Math.pow(10, 2));\\n gConstant.valueProperty().addListener(new ChangeListener() {\\n @Override\\n public void changed(ObservableValue observable, Number oldValue, Number newValue) {\\n VectorUpdater.G = newValue.doubleValue();\\n }\\n });\\n\\n //Slider that changes simulation speed\\n Label timeLabel = new Label(\\\"Simulation Speed\\\");\\n Slider timeConstant = new Slider(0, 10, 0);\\n timeConstant.valueProperty().addListener(new ChangeListener() {\\n @Override\\n public void changed(ObservableValue observable, Number oldValue, Number newValue) {\\n delay = newValue.longValue();\\n }\\n });\\n\\n //Slider the controls zoom\\n Label zoomLabel = new Label(\\\"Zoom\\\");\\n Slider zoom = new Slider(-50000, 10000, -10000);\\n zoom.valueProperty().addListener(new ChangeListener() {\\n @Override\\n public void changed(ObservableValue observable, Number oldValue, Number newValue) {\\n camera.setTranslateZ(newValue.doubleValue());\\n }\\n });\\n\\n //All control text fields\\n TextField massField = new TextField(\\\"Mass\\\");\\n TextField radiusField = new TextField(\\\"Radius\\\");\\n TextField x = new TextField(\\\"X Coordinate\\\");\\n TextField y = new TextField(\\\"Y Coordinate\\\");\\n TextField z = new TextField(\\\"Z Coordinate\\\");\\n TextField vx = new TextField(\\\"X Velocity\\\");\\n TextField vy = new TextField(\\\"Y Velocity\\\");\\n TextField vz = new TextField(\\\"Z Velocity\\\");\\n Label pad = new Label();\\n pad.setPrefHeight(40);\\n\\n //Control buttons\\n Button addSphere = new Button(\\\"Add Sphere\\\");\\n HBox buttons = new HBox(5);\\n Button toggle = new Button(\\\"Start\\\");\\n Button clear = new Button(\\\"Clear\\\");\\n buttons.setAlignment(Pos.CENTER);\\n buttons.getChildren().addAll(toggle, clear);\\n\\n //Adds items to control menu\\n controls.getChildren().addAll(massField, radiusField, x, y, z, vx, vy, vz, addSphere, pad, gLabel, gConstant, timeLabel,\\n timeConstant, zoomLabel, zoom, buttons);\\n\\n //Animates program\\n AnimationTimer timer = new AnimationTimer() {\\n long time = System.nanoTime();\\n\\n @Override\\n public void handle(long now) {\\n if ((now - time) * Math.pow(10, -7) > delay) {\\n VectorUpdater.updateVectors(spheres, 0.017);\\n for (PhysicalSphere sphere : spheres) {\\n double dx = sphere.getVelocityVector().getX() * 0.017;\\n double dy = sphere.getVelocityVector().getY() * 0.017;\\n double dz = sphere.getVelocityVector().getZ() * 0.017;\\n sphere.setTranslateX(sphere.getTranslateX() + dx);\\n sphere.setTranslateY(sphere.getTranslateY() + dy);\\n sphere.setTranslateZ(sphere.getTranslateZ() + dz);\\n }\\n time = now;\\n }\\n }\\n };\\n\\n\\n addSphere.setOnAction(event -> {\\n //Checks all text fields and formats ones that are not numbers\\n for (Node field : controls.getChildren()) {\\n if (field instanceof TextField) {\\n try {\\n Double.parseDouble(((TextField) field).getText());\\n } catch (Exception e) {\\n ((TextField) field).setText(\\\"0\\\");\\n }\\n }\\n }\\n //Velocity vector\\n Point3D velocity = new Point3D(Double.parseDouble(vx.getText()), Double.parseDouble(vy.getText()),\\n Double.parseDouble(vz.getText()));\\n double mass = Double.parseDouble(massField.getText());\\n double radius = Double.parseDouble(radiusField.getText());\\n if(mass == 0)\\n mass = 500;\\n if(radius == 0)\\n radius = 500;\\n PhysicalSphere sphere = new PhysicalSphere(radius, mass, velocity);\\n group.getChildren().add(sphere);\\n sphere.setTranslateX(Double.parseDouble(x.getText()));\\n sphere.setTranslateY(Double.parseDouble(y.getText()));\\n sphere.setTranslateZ(Double.parseDouble(z.getText()));\\n spheres.add(sphere);\\n massField.setText(\\\"Mass\\\");\\n radiusField.setText(\\\"Radius\\\");\\n vx.setText(\\\"X Velocity\\\");\\n vy.setText(\\\"Y Velocity\\\");\\n vz.setText(\\\"Z Velocity\\\");\\n x.setText(\\\"X Coordinate\\\");\\n y.setText(\\\"Y Coordinate\\\");\\n z.setText(\\\"Z Coordinate\\\");\\n });\\n\\n //Clears spheres\\n clear.setOnAction(event -> {\\n group.getChildren().clear();\\n spheres.clear();\\n });\\n\\n //Toggles timer\\n toggle.setOnAction(event -> {\\n if (toggle.getText().equals(\\\"Start\\\")) {\\n timer.start();\\n toggle.setText(\\\"Stop\\\");\\n } else {\\n timer.stop();\\n toggle.setText(\\\"Start\\\");\\n }\\n });\\n\\n //Gets anchor\\n world.setOnMousePressed(event -> {\\n anchorX = event.getSceneX();\\n anchorY = event.getSceneY();\\n });\\n\\n //Adds drag amount to anchor\\n world.setOnMouseDragged(event -> {\\n camera.setTranslateX(cameraX + (anchorX - event.getSceneX()) * 10);\\n camera.setTranslateY(cameraY + (anchorY - event.getSceneY()) * 10);\\n });\\n\\n //Logs new camera location\\n world.setOnMouseReleased(event -> {\\n cameraX = camera.getTranslateX();\\n cameraY = camera.getTranslateY();\\n });\\n\\n //Create border layout\\n BorderPane layout = new BorderPane();\\n layout.setPadding(new Insets(0, 10, 0, 10));\\n layout.setCenter(world);\\n layout.setRight(controls);\\n\\n //Create main scene and add layout\\n Scene scene = new Scene(layout, WIDTH, HEIGHT, true);\\n world.setFill(Color.LIGHTSTEELBLUE);\\n world.setCamera(camera);\\n\\n //Make the main stage\\n primaryStage.setTitle(\\\"3D Physics Simulation\\\");\\n primaryStage.setScene(scene);\\n primaryStage.show();\\n }\",\n \"public static double volumeOfSphere(double r) {\\n double v = 4.0 / 3.0 * Math.PI * Math.pow(r, 3);\\n v = (double) Math.round(v * 100) / 100;\\n return v;\\n }\",\n \"public void update() { \\n rS = globeR;\\n // *Generate the vector of the obj on the surface\\n drawPosS = sphereToCart(lon, lat, rS);\\n // *Generate the vector of the obj inside the globe\\n drawPosD = sphereToCart(lon, lat, rD);\\n }\",\n \"public MPolygon computeVertex_xyz(FOV f) {\\r\\n\\r\\n\\t\\tMPolygon mpolygon = new MPolygon();\\r\\n\\r\\n\\t\\tdouble radian1 = MPolygon.toRadian(450 - (f.getDirection() - f.gethAngle() / 2));\\r\\n\\t\\tdouble radian2 = MPolygon.toRadian(450 - (f.getDirection() - f.gethAngle() / 4));\\r\\n\\t\\tdouble radian3 = MPolygon.toRadian(450 - (f.getDirection() + f.gethAngle() / 4));\\r\\n\\t\\tdouble radian4 = MPolygon.toRadian(450 - (f.getDirection() + f.gethAngle() / 2));\\r\\n\\t\\tdouble radianD = MPolygon.toRadian(450 - f.getDirection());\\r\\n\\r\\n\\t\\tMPoint p1 = new MPoint();\\r\\n\\t\\tp1.x = f.getLatitude() + Math.cos(f.getVeiwDist() * (radian1 * Math.PI / 180));\\r\\n\\t\\tp1.y = f.getLongitude() + Math.sin(f.getVeiwDist() * (radian1 * Math.PI / 180));\\r\\n\\r\\n\\t\\tMPoint p2 = new MPoint();\\r\\n\\t\\tp2.x = f.getLatitude() + Math.cos(f.getVeiwDist() * (radian2 * Math.PI / 180));\\r\\n\\t\\tp2.y = f.getLongitude() + Math.sin(f.getVeiwDist() * (radian2 * Math.PI / 180));\\r\\n\\r\\n\\t\\tMPoint p3 = new MPoint();\\r\\n\\t\\tp3.x = f.getLatitude() + Math.cos(f.getVeiwDist() * (radian3 * Math.PI / 180));\\r\\n\\t\\tp3.y = f.getLongitude() + Math.sin(f.getVeiwDist() * (radian3 * Math.PI / 180));\\r\\n\\r\\n\\t\\tMPoint p4 = new MPoint();\\r\\n\\t\\tp4.x = f.getLatitude() + Math.cos(f.getVeiwDist() * (radian4 * Math.PI / 180));\\r\\n\\t\\tp4.y = f.getLongitude() + Math.sin(f.getVeiwDist() * (radian4 * Math.PI / 180));\\r\\n\\r\\n\\t\\tMPoint D = new MPoint();\\r\\n\\t\\tD.x = f.getLatitude() + Math.cos(f.getVeiwDist() * (radianD * Math.PI / 180));\\r\\n\\t\\tD.y = f.getLongitude() + Math.sin(f.getVeiwDist() * (radianD * Math.PI / 180));\\r\\n\\r\\n\\t\\tMPoint location = new MPoint();\\r\\n\\t\\tlocation.x = f.getLatitude();\\r\\n\\t\\tlocation.y = f.getLongitude();\\r\\n\\t\\tmpolygon.setP1(p1);\\r\\n\\t\\tmpolygon.setP2(p2);\\r\\n\\t\\tmpolygon.setP3(p2);\\r\\n\\t\\tmpolygon.setP4(p4);\\r\\n\\t\\tmpolygon.setD(D);\\r\\n\\t\\tmpolygon.setLocation(location);\\r\\n\\r\\n\\t\\treturn mpolygon;\\r\\n\\r\\n\\t}\",\n \"public void makeCylinder (float radius, int radialDivisions, int heightDivisions)\\r\\n {\\r\\n \\t// Midpoint for top and bottom surfaces\\r\\n \\tPoint midTop = new Point( 0f, 0.5f, 0f);\\r\\n \\tPoint midBot = new Point( 0f, -0.5f, 0f );\\r\\n \\t\\r\\n \\tPoint upper[] = new Point[radialDivisions + 1];\\r\\n \\tPoint lower[] = new Point[radialDivisions + 1];\\r\\n \\t\\r\\n \\t// Calculate x and z coordinates using parametric equations\\r\\n \\t// Top circular surface\\r\\n \\tfor(int i = 0; i <= radialDivisions; i ++)\\r\\n \\t{\\r\\n \\t\\tupper[i] = new Point();\\r\\n \\t\\t\\r\\n \\t\\tupper[i].x = radius * (float)( Math.cos( Math.toRadians((360.0/radialDivisions ) * i ) ) );\\r\\n \\t\\tupper[i].z = radius * (float)( Math.sin( Math.toRadians((360.0/radialDivisions ) * i ) ) );\\r\\n \\t\\tupper[i].y = 0.5f;\\r\\n \\t\\t\\r\\n \\t}\\r\\n \\t\\r\\n \\t// Bottom circle\\r\\n \\tfor(int i = 0; i <= radialDivisions; i ++)\\r\\n \\t{\\r\\n \\t\\tlower[i] = new Point();\\r\\n \\t\\t\\r\\n \\t\\tlower[i].x = radius * (float)( Math.cos( ( Math.toRadians(360.0/radialDivisions * ( i ) ) ) ) );\\r\\n \\t\\tlower[i].z = radius * (float)( Math.sin( ( Math.toRadians(360.0/radialDivisions * ( i ) ) ) ) );\\r\\n \\t\\tlower[i].y = -0.5f;\\r\\n \\t\\t\\r\\n \\t}\\r\\n \\t\\r\\n \\t// Print both the top and bottom circular faces\\r\\n \\tfor( int i = 0; i < radialDivisions; i ++ )\\r\\n \\t{\\r\\n \\t\\tthis.addTriangle(midTop.x, midTop.y, midTop.z, upper[i + 1].x, upper[i + 1].y, upper[i + 1].z, upper[i].x, upper[i].y, upper[i].z);\\r\\n \\t}\\r\\n \\t\\r\\n \\tfor( int i = 0; i < radialDivisions; i ++ )\\r\\n \\t{\\r\\n \\t\\tthis.addTriangle(midBot.x, midBot.y, midBot.z, lower[i].x, lower[i].y, lower[i].z, lower[i + 1].x, lower[i + 1].y, lower[i + 1].z);\\r\\n \\t}\\r\\n \\t\\r\\n \\t\\r\\n \\t\\r\\n \\t// Curved Surface\\r\\n \\tfloat v = -0.5f;\\r\\n \\t\\r\\n \\tfloat vert[] = new float[heightDivisions + 1];\\r\\n \\t\\r\\n \\tfor( int i = 0; i <= heightDivisions; i++)\\r\\n \\t{\\r\\n \\t\\tvert[i] = v;\\r\\n \\t\\tv = v + (float)(1/(float)heightDivisions);\\r\\n \\t}\\r\\n \\t\\r\\n \\t// Display the curved surface faces\\r\\n \\tfor( int j = 0; j < heightDivisions; j ++ )\\r\\n \\t\\tfor(int k = 0; k < radialDivisions; k ++ )\\r\\n \\t\\t{\\r\\n \\t\\t\\tif( k == radialDivisions - 1 )\\r\\n \\t\\t\\t{\\r\\n \\t\\t\\t\\tPoint tempP1 = new Point(lower[k].x, vert[j], lower[k].z);\\r\\n \\t\\t\\t\\tPoint tempP2 = new Point(lower[0].x, vert[j], lower[0].z);\\r\\n \\t\\t\\t\\tPoint tempP3 = new Point(lower[0].x, vert[j + 1], lower[0].z);\\r\\n \\t\\t\\t\\tPoint tempP4 = new Point(lower[k].x, vert[j + 1], lower[k].z);\\r\\n \\t\\t\\t\\t\\r\\n \\t\\t\\t\\taddTriangle(tempP1.x, tempP1.y, tempP1.z, tempP4.x, tempP4.y, tempP4.z, tempP3.x, tempP3.y, tempP3.z );\\r\\n \\t\\t\\taddTriangle(tempP1.x, tempP1.y, tempP1.z, tempP3.x, tempP3.y, tempP3.z, tempP2.x, tempP2.y, tempP2.z);\\r\\n \\t\\t\\t}\\r\\n \\t\\t\\telse\\r\\n \\t\\t\\t{\\r\\n \\t\\t\\t\\tPoint tempP1 = new Point(lower[k].x, vert[j], lower[k].z);\\r\\n \\t\\t\\t\\tPoint tempP2 = new Point(lower[k + 1].x, vert[j], lower[k + 1].z);\\r\\n \\t\\t\\t\\tPoint tempP3 = new Point(lower[k + 1].x, vert[j + 1], lower[k + 1].z);\\r\\n \\t\\t\\t\\tPoint tempP4 = new Point(lower[k].x, vert[j + 1], lower[k].z);\\r\\n \\t\\t\\t\\t\\r\\n \\t\\t\\t\\taddTriangle(tempP1.x, tempP1.y, tempP1.z, tempP4.x, tempP4.y, tempP4.z, tempP3.x, tempP3.y, tempP3.z );\\r\\n \\t\\t\\taddTriangle(tempP1.x, tempP1.y, tempP1.z, tempP3.x, tempP3.y, tempP3.z, tempP2.x, tempP2.y, tempP2.z);\\r\\n \\t\\t\\t}\\r\\n \\t\\t}\\r\\n }\",\n \"static void trial4() {\\n ModelBuilder modelBuilder = new ModelBuilder();\\n Model cubeModel = modelBuilder.createBox(\\n 5f,\\n 5f,\\n 5f,\\n new Material( ColorAttribute.createDiffuse(Color.GREEN) ),\\n Usage.Position);\\n Mesh cubeMesh = cubeModel.meshes.get(0);\\n\\n // There are 36 vertex indices\\n // I take it this is because there are 2 triangle per face\\n // 3 x 2 x 6 = 36\\n System.err.println(cubeMesh.getNumIndices());\\n\\n short[] cubeIndices = new short[36];\\n cubeMesh.getIndices(cubeIndices);\\n for (int i = 0; i < 36; i+=3) {\\n for (int j = 0; j <= 2; j++) {\\n System.err.printf(\\\"%3d \\\", cubeIndices[i+j]);\\n }\\n System.err.println();\\n }\\n\\n }\",\n \"public static Scene scene7() {\\r\\n\\t\\tPoint cameraPosition = new Point(-3.0, 1.0, 6.0);\\r\\n\\t\\tScene finalScene = new Scene().initAmbient(new Vec(1.0))\\r\\n\\t\\t\\t\\t.initCamera(/* Camera Position = */cameraPosition,\\r\\n\\t\\t\\t\\t\\t\\t/* Towards Vector = */ new Vec(0.0, -0.1 ,-1.0),\\r\\n\\t\\t\\t\\t\\t\\t/* Up vector = */new Vec(0.0, 1.0, 0.0),\\r\\n\\t\\t\\t\\t\\t\\t/*Distance to plain =*/ 2.0)\\r\\n\\t\\t\\t\\t.initName(\\\"scene7\\\").initAntiAliasingFactor(1)\\r\\n\\t\\t\\t\\t.initBackgroundColor(new Vec(0.01,0.19,0.22))\\r\\n\\t\\t\\t\\t.initRenderRefarctions(true).initRenderReflections(true).initMaxRecursionLevel(3);\\r\\n\\r\\n\\t\\tShape plainShape = new Plain(new Vec(0.0,-4.3,0.0), new Point(0.0, -4.3, 0.0));\\r\\n\\t\\tMaterial plainMat = Material.getMetalMaterial()\\r\\n\\t\\t\\t\\t.initKa(new Vec(0.11,0.09,0.02)).initReflectionIntensity(0.1);\\r\\n\\t\\tSurface plainSurface = new Surface(plainShape, plainMat);\\r\\n\\t\\tfinalScene.addSurface(plainSurface);\\r\\n\\r\\n\\t\\tShape transparentSphere = new Sphere(new Point(1.5, 0, -3.5), 4);\\r\\n\\t\\tMaterial transparentSphereMat = Material.getGlassMaterial(true)\\r\\n\\t\\t\\t\\t.initRefractionIntensity(0.8).initRefractionIndex(1.35).initReflectionIntensity(0.4);\\r\\n\\t\\tSurface transparentSphereSurface = new Surface(transparentSphere, transparentSphereMat);\\r\\n\\t\\tfinalScene.addSurface(transparentSphereSurface);\\r\\n\\r\\n\\t\\tPoint sunPosition = new Point(0, 3, -45);\\r\\n\\t\\tShape sunDome = new Dome(sunPosition, 8, new Vec(0, 1, 0));\\r\\n\\t\\tMaterial sunDomeMat = Material.getMetalMaterial().initKa(new Vec(0.95,0.84,0.03));\\r\\n\\t\\tSurface sunDomeSurface = new Surface(sunDome, sunDomeMat);\\r\\n\\t\\tfinalScene.addSurface(sunDomeSurface);\\r\\n\\r\\n\\t\\tVec sunDirection = cameraPosition.sub(sunPosition);\\r\\n\\t\\tLight sunLight = new DirectionalLight(sunDirection, new Vec(0.95,0.84,0.03));\\r\\n\\t\\tfinalScene.addLightSource(sunLight);\\r\\n\\r\\n\\t\\treturn finalScene;\\r\\n\\t}\",\n \"public Sphere2(\\n\\t\\t\\tString description, Vector3D centre, double radius,\\n\\t\\t\\tboolean inverse,\\n\\t\\t\\tSurfaceProperty surfaceProperty,\\n\\t\\t\\tSceneObject parent,\\n\\t\\t\\tStudio studio\\n\\t\\t)\\n\\t{\\n\\t\\tsuper(description, surfaceProperty, parent, studio);\\n\\t\\tthis.centre = centre; //passes current sphere's center and radius\\n\\t\\tthis.radius = radius;\\n\\t\\tthis.inverse = inverse;\\n\\t}\",\n \"public StarsMesh() {\\r\\n\\r\\n\\t\\tvertices = new float[star_count * 3];\\r\\n\\t\\tindices = new short[star_count];\\r\\n\\r\\n\\t\\tRandom gen = new Random(System.currentTimeMillis());\\r\\n\\r\\n\\t\\tfor (int x = 0; x < star_count * 3; x += 3) {\\r\\n\\t\\t\\tint rand;\\r\\n\\r\\n\\t\\t\\twhile ((rand = gen.nextInt(250) - 125) == 0)\\r\\n\\t\\t\\t\\t;\\r\\n\\t\\t\\tvertices[x] = rand;\\r\\n\\r\\n\\t\\t\\twhile ((rand = gen.nextInt(130) - 65) == 0)\\r\\n\\t\\t\\t\\t;\\r\\n\\t\\t\\tvertices[x + 1] = rand;\\r\\n\\r\\n\\t\\t\\twhile ((rand = gen.nextInt(200) - 100) == 0)\\r\\n\\t\\t\\t\\t;\\r\\n\\t\\t\\tvertices[x + 2] = rand;\\r\\n\\r\\n\\t\\t\\t// vertices[x+2] = 0;\\r\\n\\r\\n\\t\\t\\tindices[x / 3] = (short) ((short) x / 3);\\r\\n\\t\\t}\\r\\n\\r\\n\\t\\tByteBuffer vbb = ByteBuffer.allocateDirect(vertices.length * 4);\\r\\n\\t\\tvbb.order(ByteOrder.nativeOrder());\\r\\n\\t\\tvertexBuffer = vbb.asFloatBuffer();\\r\\n\\t\\tvertexBuffer.put(vertices);\\r\\n\\t\\tvertexBuffer.position(0);\\r\\n\\r\\n\\t\\tByteBuffer ibb = ByteBuffer.allocateDirect(indices.length * 2);\\r\\n\\t\\tibb.order(ByteOrder.nativeOrder());\\r\\n\\t\\tindexBuffer = ibb.asShortBuffer();\\r\\n\\t\\tindexBuffer.put(indices);\\r\\n\\t\\tindexBuffer.position(0);\\r\\n\\t}\",\n \"protected void skybox() {\\n Triple pos1, pos2, pos3, pos4, pos5, pos6, pos7, pos8, col1, col2, col3, col4;\\n\\n pos1 = new Triple(0, 0, 0);\\n pos2 = new Triple(100, 0, 0);\\n pos3 = new Triple(100, 0, 100);\\n pos4 = new Triple(0, 0, 100);\\n pos5 = new Triple(0, 100, 0);\\n pos6 = new Triple(100, 100, 0);\\n pos7 = new Triple(100, 100, 100);\\n pos8 = new Triple(0, 100, 100);\\n\\n // Front Triangles\\n frozenSoups.addTri( new Triangle(new Vertex(pos1, 0, 0),\\n new Vertex(pos2, .25, 0),\\n new Vertex(pos3, .25, 1),\\n 21 ) );\\n\\n frozenSoups.addTri( new Triangle(new Vertex(pos3, .25, 1),\\n new Vertex(pos4, 0, 1),\\n new Vertex(pos1, 0, 0),\\n 21 ) );\\n\\n // Left Triangles\\n frozenSoups.addTri( new Triangle(new Vertex(pos1, 1, 0),\\n new Vertex(pos5, .75, 0),\\n new Vertex(pos8, .75, 1),\\n 21 ) );\\n\\n frozenSoups.addTri( new Triangle(new Vertex(pos8, .75, 1),\\n new Vertex(pos4, 1, 1),\\n new Vertex(pos1, 1, 0),\\n 21 ) );\\n\\n // Right Triangles\\n frozenSoups.addTri( new Triangle(new Vertex(pos2, .25, 0),\\n new Vertex(pos6, .5, 0),\\n new Vertex(pos7, .5, 1),\\n 21 ) );\\n\\n frozenSoups.addTri( new Triangle(new Vertex(pos7, .5, 1),\\n new Vertex(pos3, .25, 1),\\n new Vertex(pos2, .25, 0),\\n 21 ) );\\n\\n // Back Triangles\\n frozenSoups.addTri( new Triangle(new Vertex(pos5, .75, 0),\\n new Vertex(pos6, .5, 0),\\n new Vertex(pos7, .5, 1),\\n 21 ) );\\n\\n frozenSoups.addTri( new Triangle(new Vertex(pos7, .5, 1),\\n new Vertex(pos8, .75, 1),\\n new Vertex(pos5, .75, 0),\\n 21 ) );\\n\\n // Top Triangles\\n// frozenSoups.addTri( new Triangle(new Vertex(pos4, 0, 0),\\n// new Vertex(pos3, 0, 1),\\n// new Vertex(pos7, 1, 1),\\n// 20 ) );\\n\\n// frozenSoups.addTri( new Triangle(new Vertex(pos7, 0, 0),\\n// new Vertex(pos8, 1, 0),\\n// new Vertex(pos4, 1, 1),\\n// 20 ) );\\n }\",\n \"public QuadMesh\\n (boolean isBeingSplit,\\n Matrix4f cubeMatrix, \\n\\t\\tVector3f color,\\n\\t\\tboolean inAtmosphere, \\n\\t\\tVector3f meshOffset, \\n\\t\\tboolean inFrustum, \\n\\t\\tfloat arcLengthOverSize, \\n\\t\\tVector3f center, \\n\\t\\tfloat intensity, \\n\\t\\tTexture2D Heightmap, \\n\\t\\tString f ,\\n\\t\\tQuadMesh p, \\n\\t\\tVector3f v1, \\n\\t\\tVector3f v2, \\n\\t\\tVector3f v3, \\n\\t\\tVector3f v4,\\n\\t\\tfloat size,\\n\\t\\tint x, \\n\\t\\tint y, \\n\\t\\tboolean hasChildren, \\n\\t\\tArrayList children, \\n\\t\\tBoundingSphere sphere, \\n\\t\\tGeometry mesh, \\n\\t\\tVector3f faceIndex, \\n\\t\\tfloat centerOff,\\n\\t\\tGeometry bsp)\\t\\n{\\n\\t\\tfirst = v1;\\n\\t\\tsecond = v2;\\n\\t\\tthird = v3;\\n\\t\\tfourth = v4;\\n\\t\\twidth = size;\\n\\t\\tindex1 = x;\\n\\t\\tindex2 = y;\\n\\t\\tthis.hasChildren = hasChildren;\\n\\t\\tthis.children = children;\\n\\t\\tparent = p;\\n\\t\\tface = f;\\n\\t\\tthis.sphere = sphere;\\n\\t\\tthis.mesh = mesh;\\n\\t\\tthis.faceIndex = faceIndex;\\n\\t\\tthis.centerOff = centerOff;\\n\\t\\tthis.Heightmap = Heightmap;\\n\\t\\tthis.intensity = intensity;\\n\\t\\tthis.arcLengthOverSize = arcLengthOverSize;\\n\\t\\tthis.center = center;\\n\\t\\tthis.inFrustum = inFrustum;\\n\\t\\tthis.meshOffset = meshOffset;\\n\\t\\tthis.inAtmosphere = inAtmosphere;\\n\\t\\tthis.color = color;\\n\\t\\tthis.cubeMatrix = cubeMatrix;\\n\\t\\tthis.bsp = bsp;\\n\\n\\t\\n\\t}\",\n \"private void createCube(float x, float y, float z){\\r\\n\\t\\tboolean[] sides = checkCubeSides((int)x,(int)y,(int)z);\\r\\n\\t\\tfloat[] color = BlockType.color(blocks[(int)x][(int)y][(int)z]);\\r\\n\\t\\t\\r\\n//\\t\\t gl.glNormal3f(0.0f, 1.0f, 0.0f);\\r\\n\\t\\tif(sides[0]){\\r\\n\\t\\t\\tvertexData.put((len)*(x+1.0f));\\r\\n\\t\\t\\tvertexData.put((len)*(y+1.0f));\\r\\n\\t\\t\\tvertexData.put(len*z);\\r\\n\\t\\t\\t\\r\\n\\t\\t\\tvertexData.put(len*x);\\r\\n\\t\\t\\tvertexData.put((len)*(y+1.0f));\\r\\n\\t\\t\\tvertexData.put(len*z);\\r\\n\\t\\t\\t\\r\\n\\t\\t\\tvertexData.put(len*x);\\r\\n\\t\\t\\tvertexData.put((len)*(y+1.0f));\\r\\n\\t\\t\\tvertexData.put((len)*(z+1.0f));\\r\\n\\t\\t\\t\\r\\n\\t\\t\\t\\r\\n\\t\\t\\tvertexData.put(len*x);\\r\\n\\t\\t\\tvertexData.put((len)*(y+1.0f));\\r\\n\\t\\t\\tvertexData.put((len)*(z+1.0f));\\r\\n\\t\\t\\t\\r\\n\\t\\t\\tvertexData.put((len)*(x+1.0f));\\r\\n\\t\\t\\tvertexData.put((len)*(y+1.0f));\\r\\n\\t\\t\\tvertexData.put((len)*(z+1.0f));\\r\\n\\t\\t\\t\\r\\n\\t\\t\\tvertexData.put((len)*(x+1.0f));\\r\\n\\t\\t\\tvertexData.put((len)*(y+1.0f));\\r\\n\\t\\t\\tvertexData.put(len*z);\\r\\n\\t\\t\\t\\r\\n\\t\\t\\tvertexCount += 6;\\r\\n\\t\\t\\tfor(int i = 0; i < 6; i++){\\r\\n\\t\\t\\t\\tnormalData.put(0f);\\r\\n\\t\\t\\t\\tnormalData.put(1f);\\r\\n\\t\\t\\t\\tnormalData.put(0f);\\r\\n\\t\\t\\t\\tcolorsData.put(color[0]);\\r\\n\\t\\t\\t\\tcolorsData.put(color[1]);\\r\\n\\t\\t\\t\\tcolorsData.put(color[2]);\\r\\n\\t\\t\\t}\\r\\n\\t\\t}\\r\\n\\t \\r\\n//\\t // Bottom-face\\r\\n//\\t gl.glNormal3f(0.0f, -1.0f, 0.0f);\\r\\n\\t\\t\\r\\n\\t\\tif(sides[1]){\\r\\n\\t\\t\\tvertexData.put(len*x);\\r\\n\\t\\t\\tvertexData.put(len*y);\\r\\n\\t\\t\\tvertexData.put((len)*(z+1.0f));\\r\\n\\t\\t\\t\\r\\n\\t\\t\\tvertexData.put(len*x);\\r\\n\\t\\t\\tvertexData.put(len*y);\\r\\n\\t\\t\\tvertexData.put(len*z);\\r\\n\\t\\t\\t\\r\\n\\t\\t\\tvertexData.put((len)*(x+1.0f));\\r\\n\\t\\t\\tvertexData.put(len*y);\\r\\n\\t\\t\\tvertexData.put(len*z);\\r\\n\\t\\t\\t\\r\\n\\t\\t\\tvertexData.put((len)*(x+1.0f));\\r\\n\\t\\t\\tvertexData.put(len*y);\\r\\n\\t\\t\\tvertexData.put((len)*(z+1.0f));\\r\\n\\t\\t\\t\\r\\n\\t\\t\\tvertexData.put(len*x);\\r\\n\\t\\t\\tvertexData.put(len*y);\\r\\n\\t\\t\\tvertexData.put((len)*(z+1.0f));\\r\\n\\t\\t\\t\\r\\n\\t\\t\\tvertexData.put((len)*(x+1.0f));\\r\\n\\t\\t\\tvertexData.put(len*y);\\r\\n\\t\\t\\tvertexData.put(len*z);\\r\\n\\t\\t\\t\\r\\n\\t\\t\\tvertexCount += 6;\\r\\n\\t\\t\\tfor(int i = 0; i < 6; i++){\\r\\n\\t\\t\\t\\tnormalData.put(0f);\\r\\n\\t\\t\\t\\tnormalData.put(-1f);\\r\\n\\t\\t\\t\\tnormalData.put(0f);\\r\\n\\t\\t\\t\\tcolorsData.put(color[0]);\\r\\n\\t\\t\\t\\tcolorsData.put(color[1]);\\r\\n\\t\\t\\t\\tcolorsData.put(color[2]);\\r\\n\\t\\t\\t}\\r\\n\\t\\t}\\r\\n//\\t // Back-face\\r\\n//\\t gl.glNormal3f(0.0f, 0.0f, -1.0f);\\r\\n\\t\\tif(sides[2]){\\r\\n\\t\\t\\tvertexData.put((len)*(x+1.0f));\\r\\n\\t\\t\\tvertexData.put(len*y);\\r\\n\\t\\t\\tvertexData.put(len*z);\\r\\n\\t\\t\\t\\r\\n\\t\\t\\tvertexData.put(len*x);\\r\\n\\t\\t\\tvertexData.put(len*y);\\r\\n\\t\\t\\tvertexData.put(len*z);\\r\\n\\t\\t\\t\\r\\n\\t\\t\\tvertexData.put(len*x);\\r\\n\\t\\t\\tvertexData.put((len)*(y+1.0f));\\r\\n\\t\\t\\tvertexData.put(len*z);\\r\\n\\t\\t\\t\\r\\n\\t\\t\\tvertexData.put(len*x);\\r\\n\\t\\t\\tvertexData.put((len)*(y+1.0f));\\r\\n\\t\\t\\tvertexData.put(len*z);\\r\\n\\t\\t\\t\\r\\n\\t\\t\\tvertexData.put((len)*(x+1.0f));\\r\\n\\t\\t\\tvertexData.put((len)*(y+1.0f));\\r\\n\\t\\t\\tvertexData.put(len*z);\\r\\n\\t\\t\\t\\r\\n\\t\\t\\tvertexData.put((len)*(x+1.0f));\\r\\n\\t\\t\\tvertexData.put(len*y);\\r\\n\\t\\t\\tvertexData.put(len*z);\\r\\n\\t\\t\\t\\r\\n\\t\\t\\tvertexCount += 6;\\r\\n\\t\\t\\tfor(int i = 0; i < 6; i++){\\r\\n\\t\\t\\t\\tnormalData.put(0f);\\r\\n\\t\\t\\t\\tnormalData.put(0f);\\r\\n\\t\\t\\t\\tnormalData.put(-1f);\\r\\n\\t\\t\\t\\tcolorsData.put(color[0]);\\r\\n\\t\\t\\t\\tcolorsData.put(color[1]);\\r\\n\\t\\t\\t\\tcolorsData.put(color[2]);\\r\\n\\t\\t\\t}\\r\\n\\t\\t}\\r\\n//\\t // Front-face\\r\\n//\\t gl.glNormal3f(0.0f, 0.0f, 1.0f);\\r\\n\\t\\tif(sides[3]){\\r\\n\\t\\t\\tvertexData.put((len)*(x+1.0f));\\r\\n\\t\\t\\tvertexData.put((len)*(y+1.0f));\\r\\n\\t\\t\\tvertexData.put((len)*(z+1.0f));\\r\\n\\t\\t\\t\\r\\n\\t\\t\\tvertexData.put(len*x);\\r\\n\\t\\t\\tvertexData.put((len)*(y+1.0f));\\r\\n\\t\\t\\tvertexData.put((len)*(z+1.0f));\\r\\n\\t\\t\\t\\r\\n\\t\\t\\tvertexData.put(len*x);\\r\\n\\t\\t\\tvertexData.put(len*y);\\r\\n\\t\\t\\tvertexData.put((len)*(z+1.0f));\\r\\n\\t\\t\\t\\r\\n\\t\\t\\tvertexData.put((len)*(x+1.0f));\\r\\n\\t\\t\\tvertexData.put(len*y);\\r\\n\\t\\t\\tvertexData.put((len)*(z+1.0f));\\r\\n\\t\\t\\t\\r\\n\\t\\t\\tvertexData.put((len)*(x+1.0f));\\r\\n\\t\\t\\tvertexData.put((len)*(y+1.0f));\\r\\n\\t\\t\\tvertexData.put((len)*(z+1.0f));\\r\\n\\t\\t\\t\\r\\n\\t\\t\\tvertexData.put(len*x);\\r\\n\\t\\t\\tvertexData.put(len*y);\\r\\n\\t\\t\\tvertexData.put((len)*(z+1.0f));\\r\\n\\t\\t\\t\\r\\n\\t\\t\\tvertexCount += 6;\\r\\n\\t\\t\\tfor(int i = 0; i < 6; i++){\\r\\n\\t\\t\\t\\tnormalData.put(0f);\\r\\n\\t\\t\\t\\tnormalData.put(0f);\\r\\n\\t\\t\\t\\tnormalData.put(1f);\\r\\n\\t\\t\\t\\tcolorsData.put(color[0]);\\r\\n\\t\\t\\t\\tcolorsData.put(color[1]);\\r\\n\\t\\t\\t\\tcolorsData.put(color[2]);\\r\\n\\t\\t\\t}\\r\\n\\t\\t}\\r\\n\\r\\n//\\t \\r\\n//\\t // Left-face\\r\\n//\\t gl.glNormal3f(-1.0f, 0.0f, 0.0f);\\r\\n\\t\\tif(sides[4]){\\r\\n\\t\\t\\tvertexData.put(len*x);\\r\\n\\t\\t\\tvertexData.put((len)*(y+1.0f));\\r\\n\\t\\t\\tvertexData.put((len)*(z+1.0f));\\r\\n\\t\\t\\t\\r\\n\\t\\t\\tvertexData.put(len*x);\\r\\n\\t\\t\\tvertexData.put((len)*(y+1.0f));\\r\\n\\t\\t\\tvertexData.put(len*z);\\r\\n\\t\\t\\t\\r\\n\\t\\t\\tvertexData.put(len*x);\\r\\n\\t\\t\\tvertexData.put(len*y);\\r\\n\\t\\t\\tvertexData.put(len*z);\\r\\n\\t\\t\\t\\r\\n\\t\\t\\tvertexData.put(len*x);\\r\\n\\t\\t\\tvertexData.put(len*y);\\r\\n\\t\\t\\tvertexData.put((len)*(z+1.0f));\\r\\n\\t\\t\\t\\r\\n\\t\\t\\tvertexData.put(len*x);\\r\\n\\t\\t\\tvertexData.put((len)*(y+1.0f));\\r\\n\\t\\t\\tvertexData.put((len)*(z+1.0f));\\r\\n\\t\\t\\t\\r\\n\\t\\t\\tvertexData.put(len*x);\\r\\n\\t\\t\\tvertexData.put(len*y);\\r\\n\\t\\t\\tvertexData.put(len*z);\\r\\n\\t\\t\\t\\r\\n\\t\\t\\tvertexCount += 6;\\r\\n\\t\\t\\tfor(int i = 0; i < 6; i++){\\r\\n\\t\\t\\t\\tnormalData.put(-1f);\\r\\n\\t\\t\\t\\tnormalData.put(0f);\\r\\n\\t\\t\\t\\tnormalData.put(0f);\\r\\n\\t\\t\\t\\tcolorsData.put(color[0]);\\r\\n\\t\\t\\t\\tcolorsData.put(color[1]);\\r\\n\\t\\t\\t\\tcolorsData.put(color[2]);\\r\\n\\t\\t\\t}\\r\\n\\t\\t}\\r\\n\\r\\n//\\t // Right-face\\r\\n//\\t gl.glNormal3f(1.0f, 0.0f, 0.0f);\\r\\n\\t\\tif(sides[5]){\\r\\n\\t\\t\\tvertexData.put((len)*(x+1.0f));\\r\\n\\t\\t\\tvertexData.put((len)*(y+1.0f));\\r\\n\\t\\t\\tvertexData.put(len*z);\\r\\n\\t\\t\\t\\r\\n\\t\\t\\tvertexData.put((len)*(x+1.0f));\\r\\n\\t\\t\\tvertexData.put((len)*(y+1.0f));\\r\\n\\t\\t\\tvertexData.put((len)*(z+1.0f));\\r\\n\\t\\t\\t\\r\\n\\t\\t\\tvertexData.put((len)*(x+1.0f));\\r\\n\\t\\t\\tvertexData.put(len*y);\\r\\n\\t\\t\\tvertexData.put((len)*(z+1.0f));\\r\\n\\t\\t\\t\\r\\n\\t\\t\\tvertexData.put((len)*(x+1.0f));\\r\\n\\t\\t\\tvertexData.put(len*y);\\r\\n\\t\\t\\tvertexData.put(len*z);\\r\\n\\t\\t\\t\\r\\n\\t\\t\\tvertexData.put((len)*(x+1.0f));\\r\\n\\t\\t\\tvertexData.put((len)*(y+1.0f));\\r\\n\\t\\t\\tvertexData.put(len*z);\\r\\n\\t\\t\\t\\r\\n\\t\\t\\tvertexData.put((len)*(x+1.0f));\\r\\n\\t\\t\\tvertexData.put(len*y);\\r\\n\\t\\t\\tvertexData.put((len)*(z+1.0f));\\r\\n\\t\\t\\t\\r\\n\\t\\t\\tvertexCount += 6;\\r\\n\\t\\t\\tfor(int i = 0; i < 6; i++){\\r\\n\\t\\t\\t\\tnormalData.put(1f);\\r\\n\\t\\t\\t\\tnormalData.put(0f);\\r\\n\\t\\t\\t\\tnormalData.put(0f);\\r\\n\\t\\t\\t\\tcolorsData.put(color[0]);\\r\\n\\t\\t\\t\\tcolorsData.put(color[1]);\\r\\n\\t\\t\\t\\tcolorsData.put(color[2]);\\r\\n\\t\\t\\t}\\r\\n\\t\\t}\\r\\n\\t}\",\n \"@Override\\n public void intersect( Ray ray, IntersectResult result ) {\\n \\t\\tVector3d e = new Vector3d(ray.eyePoint);\\n \\t\\te.sub(this.center);\\n \\t\\tdouble a = ray.viewDirection.dot(ray.viewDirection);\\n \\t\\tdouble b = 2 * ray.viewDirection.dot(e);\\n \\t\\tdouble c = e.dot(e) - this.radius * this.radius;\\n \\t\\tdouble discriminant = b*b - 4*a*c;\\n \\t\\t\\n \\t\\tif (discriminant == 0.0) {\\n \\t\\t\\t\\n \\t\\t\\tdouble t_pos = -0.5 * b / a;\\n \\t\\t\\t// scale ray viewDirection to be t_pos length\\n\\t\\t\\t// point of intersection is at ray.eyePoint + scaled viewDirection vector\\n\\t\\t\\tPoint3d point_of_intersection = new Point3d(ray.viewDirection);\\n\\t\\t\\tpoint_of_intersection.scale(t_pos);\\n\\t\\t\\tpoint_of_intersection.add(ray.eyePoint);\\n\\t\\t\\t\\n\\t\\t\\t// normal is point_of_intersection - sphere.center\\n\\t\\t\\tVector3d normal = new Vector3d();\\n\\t\\t\\tnormal.add(point_of_intersection);\\n\\t\\t\\tnormal.sub(this.center);\\n\\t\\t\\tnormal.normalize();\\n\\t\\t\\t\\n\\t\\t\\tresult.p.set(point_of_intersection);\\n\\t\\t\\tresult.material = this.material;\\n\\t\\t\\tresult.t = t_pos;\\n\\t\\t\\tresult.n.set(normal);\\n \\t\\t\\t\\n \\t\\t}\\n \\t\\telse if (discriminant > 0.0) {\\n \\t\\t\\t\\n \\t\\t\\t// solve quadratic formula\\n \\t\\t\\tdouble q = (b > 0) ? -0.5 * (b + Math.sqrt(discriminant)) : -0.5 * (b - Math.sqrt(discriminant));\\n \\t\\t\\tdouble t_pos = q / a;\\n \\t\\t\\tdouble t_neg = c / q;\\n \\t\\t\\t\\n \\t\\t\\tif (t_pos < t_neg) {\\n \\t\\t\\t\\tdouble temp = t_pos;\\n \\t\\t\\t\\tt_pos = t_neg;\\n \\t\\t\\t\\tt_neg = temp;\\n \\t\\t\\t}\\n \\t\\t\\t\\t\\n \\t\\t\\tif (t_neg > 0) {\\n \\t\\t\\t\\t// scale ray viewDirection to be t_neg length\\n \\t\\t\\t\\t// point of intersection is at ray.eyePoint + scaled viewDirection vector\\n \\t\\t\\tPoint3d point_of_intersection = new Point3d(ray.viewDirection);\\n \\t\\t\\tpoint_of_intersection.scale(t_neg);\\n \\t\\t\\tpoint_of_intersection.add(ray.eyePoint);\\n \\t\\t\\t\\n \\t\\t\\t// normal is point_of_intersection - sphere.center\\n \\t\\t\\tVector3d normal = new Vector3d();\\n \\t\\t\\tnormal.add(point_of_intersection);\\n \\t\\t\\tnormal.sub(this.center);\\n \\t\\t\\tnormal.normalize();\\n \\t\\t\\t\\n \\t\\t\\tresult.p.set(point_of_intersection);\\n \\t\\t\\tresult.material = this.material;\\n \\t\\t\\tresult.t = t_neg;\\n \\t\\t\\tresult.n.set(normal);\\n \\t\\t\\t}\\n\\t\\n \\t\\t}\\n \\t\\t\\n \\t\\t\\n \\t\\t\\n \\t\\t\\n \\t\\t\\n\\n }\",\n \"public boolean isSphereInBox(final Vec3 inP, float fRadius)\\n {\\n float fDist;\\n float fDistSq = 0;\\n Vec4 p = m.getInverseSimple().multiply(inP.toPoint());\\n\\n // Add distance squared from sphere centerpoint to box for each axis\\n for (int i = 0; i < 3; i++)\\n {\\n if (abs(p.get(i)) > extents.get(i))\\n {\\n fDist = abs(p.get(i)) - extents.get(i);\\n fDistSq += fDist * fDist;\\n }\\n }\\n\\n\\n return (fDistSq <= fRadius * fRadius);\\n }\",\n \"public static Scene scene4() {\\n\\t\\tScene finalScene = new Scene().initAmbient(new Vec(1.0))\\r\\n\\t\\t\\t\\t.initCamera(/* Camera Position = */new Point(0.0, 2.0, 6.0), \\r\\n\\t\\t\\t\\t\\t\\t/* Towards Vector = */ new Vec(0.0, -0.1 ,-1.0),\\r\\n\\t\\t\\t\\t\\t\\t/* Up vector = */new Vec(0.0, 1.0, 0.0), \\r\\n\\t\\t\\t\\t\\t\\t/*Distance to plain =*/ 2.0)\\r\\n\\t\\t\\t\\t.initName(\\\"scene4\\\").initAntiAliasingFactor(1)\\r\\n\\t\\t\\t\\t.initRenderRefarctions(true).initRenderReflections(true).initMaxRecursionLevel(6);\\r\\n // Add Surfaces to the scene.\\r\\n\\t\\t\\r\\n\\t\\t// (2) Add two domes to make it look like we split a sphere in half. \\r\\n\\t\\tShape domeShape = new Dome(new Point(2.0, 0.0, -10.0), 5.0, new Vec(1.0, 0.0, 0.0));\\r\\n\\t\\tMaterial domeMat = Material.getRandomMaterial();\\r\\n\\t\\tSurface domeSurface = new Surface(domeShape, domeMat);\\r\\n\\t\\tfinalScene.addSurface(domeSurface);\\r\\n\\t\\t\\r\\n\\t\\tdomeShape = new Dome(new Point(-2.0, 0.0, -10.0), 5.0, new Vec(-1.0, 0.0, 0.0));\\r\\n\\t\\tdomeSurface = new Surface(domeShape, domeMat);\\r\\n\\t\\tfinalScene.addSurface(domeSurface);\\r\\n\\t\\t\\r\\n\\t\\t// Add light sources:\\r\\n\\t\\tCutoffSpotlight cutoffSpotlight = new CutoffSpotlight(new Vec(0.0, -1.0, 0.0), 75.0);\\r\\n\\t\\tcutoffSpotlight.initPosition(new Point(0.0, 6.0, -10.0));\\r\\n\\t\\tcutoffSpotlight.initIntensity(new Vec(.5,0.5,0.5));\\r\\n\\t\\tfinalScene.addLightSource(cutoffSpotlight);\\r\\n\\t\\t\\r\\n\\t\\treturn finalScene;\\r\\n\\t}\",\n \"public Mesh(Primitive shape) {\\n\\t\\tswitch (shape) {\\n\\t\\t\\tcase CUBE:\\n\\t\\t\\t\\tgenerateCube();\\n\\t\\t\\t\\tbreak;\\n\\t\\t\\tcase CUBOID:\\n\\t\\t\\t\\tgenerateCube();\\n\\t\\t\\t\\tscale(2, 1, 1); // Stretch the cube along the x-axis to give a cuboid\\n\\t\\t\\t\\tbreak;\\n\\t\\t\\tcase TRIANGULAR_PRISM:\\n\\t\\t\\t\\tgeneratePrism();\\n\\t\\t\\t\\tbreak;\\n\\t\\t\\tcase SPHERE:\\n\\t\\t\\t\\tgenerateSphere();\\n\\t\\t\\t\\tbreak;\\n\\t\\t\\tcase CONVEX_LENS:\\n\\t\\t\\t\\tgenerateSphere();\\n\\t\\t\\t\\tscale(0.6, 2, 2); // Increase the size (to allow a better demonstration of how the lens works) and then squash the sphere along the x-axis\\n\\t\\t\\t\\tbreak;\\n\\t\\t\\tcase CONCAVE_LENS:\\n\\t\\t\\t\\tgenerateSphere();\\n\\t\\t\\t\\tscale(0.6, 2, 2); // Increase the size and squash along the x-axis\\n\\t\\t\\t\\t\\n\\t\\t\\t\\tfor (int i = 0; i < verts.length; i++) {\\n\\t\\t\\t\\t\\tif (verts[i].getElement(0) < -0.0001) { // Don't move points in the middle of the x-axis\\n\\t\\t\\t\\t\\t\\tverts[i].setElement(0, verts[i].getElement(0) + 0.8); // Move points on the left to the right. This part still bulges out to the left, but when it is on the right it is concave\\n\\t\\t\\t\\t\\t} else if (verts[i].getElement(0) > 0.0001) {\\n\\t\\t\\t\\t\\t\\tverts[i].setElement(0, verts[i].getElement(0) - 0.8); // Move points on the right to the left.\\n\\t\\t\\t\\t\\t}\\n\\t\\t\\t\\t}\\n\\t\\t\\t\\t// The faces are 'inside out', so the ordering of the vertices must be reversed in order to make the normals point the correct way\\n\\t\\t\\t\\tfor (int i = 0; i < faces.length; i++) {\\n\\t\\t\\t\\t\\t// Swap the first and last vertices (0 and 2)\\n\\t\\t\\t\\t\\tint temp = faces[i][0];\\n\\t\\t\\t\\t\\tfaces[i][0] = faces[i][2];\\n\\t\\t\\t\\t\\tfaces[i][2] = temp;\\n\\t\\t\\t\\t}\\n\\t\\t\\t\\tbreak;\\n\\t\\t\\tcase HALF_CYLINDER:\\n\\t\\t\\t\\tgenerateHalfCylinder();\\n\\t\\t\\t\\tbreak;\\n\\t\\t\\tdefault:\\n\\t\\t\\t\\tthrow new IllegalArgumentException(\\\"Mesh constructor cannot take a null primitive\\\");\\n\\t\\t}\\n\\t\\tnormals = new Vector[faces.length];\\n\\t\\tds = new double[faces.length];\\n\\t\\tfor (int i = 0; i < faces.length; i++) {\\n\\t\\t\\tnormals[i] = normal(faces[i]); // Calculate the normal for the face\\n\\t\\t\\tds[i] = verts[faces[i][0]].dotProduct(normals[i]); // Calculate the value of d for the face\\n\\t\\t}\\n\\t\\tcalcBoxVerts(); // Calculate and store the vertices of the AOBB\\n\\t}\",\n \"@Override\\n\\tpublic List getBoundingSpheres() {\\n\\t\\tLinkedList res = new LinkedList();\\n\\t\\tBoundingSphere s1 = new BoundingSphere(0.9, new Point(0,0,0));\\n\\t\\ts1.setSphereColore3d(0,0,0);\\n\\t\\tres.add(s1);\\n\\t\\tBoundingSphere temp = this.carFront.getBoundingSpheres().get(0);\\n\\t\\tres.add(temp);\\n\\t\\ttemp = this.carCenter.getBoundingSpheres().get(0);\\n\\t\\tres.add(temp);\\n\\t\\ttemp = this.carBack.getBoundingSpheres().get(0);\\n\\t\\tres.add(temp);\\n\\n\\t\\treturn res;\\n\\n\\n\\t}\",\n \"public RayTracer() {\\n\\t\\tspheres = new ArrayList();\\n\\t\\tspheres.add(new Sphere(-2.0f, 0.0f, -15.0f, 4.0f, 1.00f, 0.32f, 0.36f, 0.1f, 0.8f, 100.0f));\\n\\t\\tspheres.add(new Sphere(5.0f, 5.0f, -15.0f, 2.0f, 0.00f, 0.92f, 0.36f, 0.1f, 0.8f, 100.0f));\\n\\t\\tspheres.add(new Sphere(10.0f, -8.0f, -30.0f, 6.0f, 0.36f, 0.32f, 1.00f, 0.1f, 0.8f, 100.0f));\\n\\n\\t\\tlight = new Light(5.0f, 10.0f, 10.0f, 1.0f); // (x, y, z, intensity).\\n\\t\\tcamera = new Camera(512, 512, 50.0f); // (width, height, fov).\\n\\t}\",\n \"public interface FrameSphere3DReadOnly extends Sphere3DReadOnly, FrameShape3DReadOnly\\n{\\n /** {@inheritDoc} */\\n @Override\\n FramePoint3DReadOnly getPosition();\\n\\n /**\\n * {@inheritDoc}\\n * vertices = triangulation.getVertices();\\n\\t\\tHashMap faces = triangulation.getFaces();\\n\\n\\t\\tHashMap chords = new HashMap();\\n\\t\\tList onOuterCircle = new LinkedList();\\n\\t\\tList outerCircle = new LinkedList();\\n\\n\\t\\tfor (Vertex v : vertices.values()) {\\n\\t\\t\\tchords.put(v.getId(), 0);\\n\\t\\t\\tchildren.put(v.getId(), new LinkedList());\\n\\t\\t}\\n\\n\\t\\t// determine outer face (randomly, use the first face)\\n\\t\\tFace outerFace = null;\\n\\t\\tfor (Face f : faces.values()) {\\n\\t\\t\\touterFace = f;\\n\\t\\t\\tbreak;\\n\\t\\t}\\n\\t\\tif (outerFace == null) {\\n\\t\\t\\t// there are no faces at all in the embedding\\n\\t\\t\\treturn;\\n\\t\\t}\\n\\n\\t\\tEdge e = outerFace.getIncidentEdge();\\n\\t\\tvertexOrder[1] = e.getSource();\\n\\t\\tvertexOrder[0] = e.getTarget();\\n\\t\\tonOuterCircle.add(e.getTarget());\\n\\t\\tonOuterCircle.add(e.getNext().getTarget());\\n\\t\\tonOuterCircle.add(e.getSource());\\n\\t\\touterCircle.add(e.getNext().getNext().getTwin());\\n\\t\\touterCircle.add(e.getNext().getTwin());\\n\\t\\t\\n\\t\\t//System.out.println(\\\"outerCircle 0 \\\" + outerCircle.get(0).getId() + \\\" - source: \\\" + outerCircle.get(0).getSource().getId() + \\\" - target: \\\" + outerCircle.get(0).getTarget().getId());\\n\\t\\t//System.out.println(\\\"outerCircle 1 \\\" + outerCircle.get(1).getId() + \\\" - source: \\\" + outerCircle.get(1).getSource().getId() + \\\" - target: \\\" + outerCircle.get(1).getTarget().getId());\\n\\t\\t\\n\\n\\t\\tfor (int k=vertexOrder.length-1; k>1; k--) {\\n\\t\\t\\t//System.out.println(\\\"k: \\\" + k + \\\" - outerCircle size: \\\" + outerCircle.size());\\n\\t\\t\\t// chose v != v_0,v_1 such that v on outer face, not considered yet and chords(v)=0\\n\\t\\t\\tVertex nextVertex = null;\\n\\t\\t\\tint nextVertexId = -1;\\n\\t\\t\\tfor (int i=0; i childrenNextVertex = children.get(nextVertexId);\\n\\t\\t\\t\\n\\t\\t\\t// update edges of outer circle\\n\\t\\t\\tint index = 0;\\n\\t\\t\\t\\n\\t\\t\\twhile (outerCircle.get(index).getTarget().getId() != nextVertexId) {\\n\\t\\t\\t\\tindex++;\\n\\t\\t\\t}\\n\\t\\t\\tEdge outofNextVertex = outerCircle.remove(index+1);\\n\\t\\t\\t\\n\\t\\t\\t\\n\\t\\t\\t//System.out.println(\\\"outOfNextVertex \\\" + outofNextVertex.getId() + \\\" - source: \\\" + outofNextVertex.getSource().getId() + \\\" - target: \\\" + outofNextVertex.getTarget().getId());\\n\\t\\t\\tEdge intoNextVertex = outerCircle.remove(index);\\n\\t\\t\\t//System.out.println(\\\"intoNextVertex \\\" + intoNextVertex.getId() + \\\" - source: \\\" + intoNextVertex.getSource().getId() + \\\" - target: \\\" + intoNextVertex.getTarget().getId());\\n\\t\\t\\tEdge current = intoNextVertex.getNext();\\n\\t\\t\\t//System.out.println(\\\"current \\\" + current.getId() + \\\" - source: \\\" + current.getSource().getId() + \\\" - target: \\\" + current.getTarget().getId());\\n\\t\\t\\t\\n\\t\\t\\tint endIndex = index;\\n\\t\\t\\t\\n\\t\\t\\twhile (current.getId() != outofNextVertex.getId()) {\\n\\t\\t\\t\\tEdge onCircle = current.getNext().getTwin();\\n\\t\\t\\t\\touterCircle.add(endIndex, onCircle);\\n\\t\\t\\t\\t\\n\\t\\t\\t\\tchildrenNextVertex.add(0, onCircle.getSource().getId());\\n\\t\\t\\t\\t\\n\\t\\t\\t\\tendIndex++;\\n\\t\\t\\t\\tcurrent = current.getTwin().getNext();\\n\\t\\t\\t\\tonOuterCircle.add(onCircle.getTarget());\\n\\t\\t\\t}\\n\\t\\t\\t\\n\\t\\t\\tEdge lastEdge = outofNextVertex.getNext().getTwin();\\n\\t\\t\\touterCircle.add(endIndex, lastEdge);\\n\\t\\t\\t\\n\\t\\t\\tchildrenNextVertex.add(0, lastEdge.getSource().getId());\\n\\t\\t\\tchildrenNextVertex.add(0, lastEdge.getTarget().getId());\\n\\n\\t\\t\\t// update chords\\n\\t\\t\\tfor (Vertex v : onOuterCircle) {\\n\\t\\t\\t\\tEdge incidentEdge = v.getOutEdge();\\n\\t\\t\\t\\tint firstEdgeId = incidentEdge.getId();\\n\\t\\t\\t\\tint chordCounter = -2; // the 2 neighbours are on the outer circle, but no chords\\n\\t\\t\\t\\tdo {\\n\\t\\t\\t\\t\\tif (onOuterCircle.contains(incidentEdge.getTarget())) {\\n\\t\\t\\t\\t\\t\\tchordCounter++;\\n\\t\\t\\t\\t\\t}\\n\\t\\t\\t\\t\\tincidentEdge = incidentEdge.getTwin().getNext();\\n\\t\\t\\t\\t} while (incidentEdge.getId() != firstEdgeId);\\n\\t\\t\\t\\tchords.put(v.getId(), chordCounter);\\n\\t\\t\\t}\\n\\t\\t}\\n\\t}\",\n \"public Vector2f[] generatePatch(){\\n\\t\\tVector2f[] vertices = new Vector2f[16];\\n\\t\\t\\n\\t\\tint index = 0;\\n\\t\\t\\n\\t\\tvertices[index++] = new Vector2f(0,0);\\n\\t\\tvertices[index++] = new Vector2f(0.333f,0);\\n\\t\\tvertices[index++] = new Vector2f(0.666f,0);\\n\\t\\tvertices[index++] = new Vector2f(1,0);\\n\\t\\t\\n\\t\\tvertices[index++] = new Vector2f(0,0.333f);\\n\\t\\tvertices[index++] = new Vector2f(0.333f,0.333f);\\n\\t\\tvertices[index++] = new Vector2f(0.666f,0.333f);\\n\\t\\tvertices[index++] = new Vector2f(1,0.333f);\\n\\t\\t\\n\\t\\tvertices[index++] = new Vector2f(0,0.666f);\\n\\t\\tvertices[index++] = new Vector2f(0.333f,0.666f);\\n\\t\\tvertices[index++] = new Vector2f(0.666f,0.666f);\\n\\t\\tvertices[index++] = new Vector2f(1,0.666f);\\n\\t\\n\\t\\tvertices[index++] = new Vector2f(0,1);\\n\\t\\tvertices[index++] = new Vector2f(0.333f,1);\\n\\t\\tvertices[index++] = new Vector2f(0.666f,1);\\n\\t\\tvertices[index++] = new Vector2f(1,1);\\n\\t\\t\\n\\t\\treturn vertices;\\n\\t}\",\n \"@Override\\n\\tpublic void create() {\\n\\t\\tthis.mesh = new Mesh(VertexDataType.VertexArray, false, 4, 6, \\n\\t\\t\\t\\tnew VertexAttribute(VertexAttributes.Usage.Position, 3, \\\"attr_position\\\"));\\n\\n\\t\\tmesh.setVertices(new float[] {\\n\\t\\t\\t\\t-8192f, -512f, 0,\\n\\t\\t\\t\\t8192f, -512f, 0,\\n\\t\\t\\t\\t8192f, 512f, 0,\\n\\t\\t\\t\\t-8192f, 512f, 0\\n\\t\\t});\\n\\t\\tmesh.setIndices(new short[] {0, 1, 2, 2, 3, 0});\\n\\n\\t\\t// creates the camera\\n\\t\\tcamera = new OrthographicCamera(CoordinateConverter.getCameraWidth(), CoordinateConverter.getCameraHeight());\\n\\n\\t\\t// Sets the positions of the camera\\n\\t\\tcamera.position.set(CoordinateConverter.getCameraWidth()/2, CoordinateConverter.getCameraHeight()/2, 0);\\n\\t\\tcamera.update();\\n\\n\\t\\t// Sets how much of the map that is shown on the screen\\n\\t\\tglViewport = new Rectangle(0, 0, CoordinateConverter.getCameraWidth(), CoordinateConverter.getCameraHeight());\\n\\t\\t\\n\\t}\",\n \"public void setup() {\\n size(1280, 720, P3D); // use the P3D OpenGL renderer\\n noStroke(); // turn off stroke (for the rest of the sketch)\\n smooth(6); // set smooth level 6 (default is 2)\\n // create all the shapes with a certain radius and height\\n for (int i=0; i moons,List ringsSpecs, List ringsColors, float speed){\\n\\t\\tPlanet planet = new Planet(radius,orbitRadius, axisTilt, ringsSpecs,ringsColors, speed);\\n\\t\\tplanet.setTexture(texture);\\n\\n\\t\\tfor(Moon moon : moons)\\n\\t\\t\\tmoon.setCenter(planet);\\n\\t\\t\\n\\t\\tplanet.addMoons(moons);\\n\\n\\t\\tplanets.add(planet);\\n\\t}\"\n]"},"negative_scores":{"kind":"list like","value":["0.73659265","0.6895095","0.6706584","0.6666535","0.66356397","0.65258765","0.6438559","0.643035","0.6427336","0.6408753","0.63298154","0.63137585","0.6279756","0.6212963","0.6166902","0.61582","0.615101","0.61340296","0.6121808","0.60497683","0.6045205","0.60441786","0.5940034","0.58949596","0.5890788","0.587355","0.5867763","0.5838663","0.5826701","0.5814331","0.57985514","0.57977295","0.57887685","0.5780659","0.57666206","0.5733907","0.56913525","0.5682943","0.56761825","0.5633592","0.56265783","0.5618454","0.5599557","0.5582138","0.5576135","0.55415136","0.552611","0.5485087","0.545191","0.5448503","0.54406095","0.5434863","0.5424582","0.54154384","0.5401783","0.54002607","0.5388309","0.5385044","0.5376233","0.53677565","0.5360125","0.5354395","0.534391","0.5343193","0.5333627","0.5265275","0.5253734","0.52486753","0.5242955","0.52097744","0.51963234","0.5182901","0.5171232","0.5164091","0.51625735","0.51591164","0.51512855","0.51495326","0.51431024","0.51377","0.5136206","0.51154155","0.5107845","0.51071614","0.5099153","0.50929654","0.5086562","0.50836074","0.5068396","0.5042416","0.5021355","0.5018724","0.50163317","0.5013991","0.5003439","0.4995468","0.4993513","0.49889165","0.49870828","0.49828243"],"string":"[\n \"0.73659265\",\n \"0.6895095\",\n \"0.6706584\",\n \"0.6666535\",\n \"0.66356397\",\n \"0.65258765\",\n \"0.6438559\",\n \"0.643035\",\n \"0.6427336\",\n \"0.6408753\",\n \"0.63298154\",\n \"0.63137585\",\n \"0.6279756\",\n \"0.6212963\",\n \"0.6166902\",\n \"0.61582\",\n \"0.615101\",\n \"0.61340296\",\n \"0.6121808\",\n \"0.60497683\",\n \"0.6045205\",\n \"0.60441786\",\n \"0.5940034\",\n \"0.58949596\",\n \"0.5890788\",\n \"0.587355\",\n \"0.5867763\",\n \"0.5838663\",\n \"0.5826701\",\n \"0.5814331\",\n \"0.57985514\",\n \"0.57977295\",\n \"0.57887685\",\n \"0.5780659\",\n \"0.57666206\",\n \"0.5733907\",\n \"0.56913525\",\n \"0.5682943\",\n \"0.56761825\",\n \"0.5633592\",\n \"0.56265783\",\n \"0.5618454\",\n \"0.5599557\",\n \"0.5582138\",\n \"0.5576135\",\n \"0.55415136\",\n \"0.552611\",\n \"0.5485087\",\n \"0.545191\",\n \"0.5448503\",\n \"0.54406095\",\n \"0.5434863\",\n \"0.5424582\",\n \"0.54154384\",\n \"0.5401783\",\n \"0.54002607\",\n \"0.5388309\",\n \"0.5385044\",\n \"0.5376233\",\n \"0.53677565\",\n \"0.5360125\",\n \"0.5354395\",\n \"0.534391\",\n \"0.5343193\",\n \"0.5333627\",\n \"0.5265275\",\n \"0.5253734\",\n \"0.52486753\",\n \"0.5242955\",\n \"0.52097744\",\n \"0.51963234\",\n \"0.5182901\",\n \"0.5171232\",\n \"0.5164091\",\n \"0.51625735\",\n \"0.51591164\",\n \"0.51512855\",\n \"0.51495326\",\n \"0.51431024\",\n \"0.51377\",\n \"0.5136206\",\n \"0.51154155\",\n \"0.5107845\",\n \"0.51071614\",\n \"0.5099153\",\n \"0.50929654\",\n \"0.5086562\",\n \"0.50836074\",\n \"0.5068396\",\n \"0.5042416\",\n \"0.5021355\",\n \"0.5018724\",\n \"0.50163317\",\n \"0.5013991\",\n \"0.5003439\",\n \"0.4995468\",\n \"0.4993513\",\n \"0.49889165\",\n \"0.49870828\",\n \"0.49828243\"\n]"},"document_score":{"kind":"string","value":"0.7976449"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":4693,"cells":{"query":{"kind":"string","value":"Creates the vertices and faces that define the approximation of a cylinder of radius 1 and height 2 that has been cut in vertically in half"},"document":{"kind":"string","value":"private void generateHalfCylinder() {\n\t\tint segments = 32;\n\t\tverts = new Vector[segments * 2];\n\t\tfaces = new int[4 * segments - 4][3];\n\t\tdouble heading = 0;\n\t\tdouble headingIncrement = Math.PI / (segments - 1); // The increment in heading between segments of vertices\n\t\tfor (int s = 0; s < segments; s++) {\n\t\t\tdouble x = Math.cos(heading); // x co-ordinate of points on the segment\n\t\t\tdouble z = Math.sin(heading); // z co-ordinate of points on the segment\n\t\t\tverts[s] = new Vector(3);\n\t\t\tverts[s].setElements(new double[] {x, -1, z}); // Vertex on the bottom semi-circle\n\t\t\tverts[s + segments] = new Vector(3);\n\t\t\tverts[s + segments].setElements(new double[] {x, 1, z}); // Vertex on the top semi-circle\n\t\t\theading += headingIncrement;\n\t\t}\n\t\tfor (int i = 0; i < segments - 1; i++) { // Vertical faces approximating the curved surface\n\t\t\tfaces[i * 2] = new int[] {i, i + segments, i + segments + 1}; // Face involving a point on the bottom semi-circle, the point directly above it (top semi-circle and the same segment) and the point directly above and one segment across\n\t\t\tfaces[i * 2 + 1] = new int[] {i, i + segments + 1, i + 1}; // Face involving a point on the bottom semi-circle, the point above and one segment across and the point one segment across on the bottom semi-circle\n\t\t}\n\t\tfor (int i = 0; i < segments - 2; i++) { // Horizontal faces approximating the semi-circles at the top and bottom\n\t\t\tfaces[segments * 2 - 2 + i] = new int[] {0, i + 1, i + 2}; // For the bottom semi-circle, the first vertex connected to the (i + 1)th vertex and the (i + 2)th vertex\n\t\t\tfaces[segments * 2 - 2 + i + segments - 2] = new int[] {segments, segments + i + 2, segments + i + 1}; // The same as above but for the top semi-circle\n\t\t}\n\t\t// Faces representing the vertical square cross-section\n\t\tfaces[4 * segments - 6] = new int[] {0, segments * 2 - 1, segments}; // The first vertex, the last vertex and the one above the first\n\t\tfaces[4 * segments - 5] = new int[] {0, segments - 1, segments * 2 - 1}; // The first vertex, the last vertex on the bottom and the last vertex (on the top)\n\t}"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["public void makeCylinder (float radius, int radialDivisions, int heightDivisions)\r\n {\r\n \t// Midpoint for top and bottom surfaces\r\n \tPoint midTop = new Point( 0f, 0.5f, 0f);\r\n \tPoint midBot = new Point( 0f, -0.5f, 0f );\r\n \t\r\n \tPoint upper[] = new Point[radialDivisions + 1];\r\n \tPoint lower[] = new Point[radialDivisions + 1];\r\n \t\r\n \t// Calculate x and z coordinates using parametric equations\r\n \t// Top circular surface\r\n \tfor(int i = 0; i <= radialDivisions; i ++)\r\n \t{\r\n \t\tupper[i] = new Point();\r\n \t\t\r\n \t\tupper[i].x = radius * (float)( Math.cos( Math.toRadians((360.0/radialDivisions ) * i ) ) );\r\n \t\tupper[i].z = radius * (float)( Math.sin( Math.toRadians((360.0/radialDivisions ) * i ) ) );\r\n \t\tupper[i].y = 0.5f;\r\n \t\t\r\n \t}\r\n \t\r\n \t// Bottom circle\r\n \tfor(int i = 0; i <= radialDivisions; i ++)\r\n \t{\r\n \t\tlower[i] = new Point();\r\n \t\t\r\n \t\tlower[i].x = radius * (float)( Math.cos( ( Math.toRadians(360.0/radialDivisions * ( i ) ) ) ) );\r\n \t\tlower[i].z = radius * (float)( Math.sin( ( Math.toRadians(360.0/radialDivisions * ( i ) ) ) ) );\r\n \t\tlower[i].y = -0.5f;\r\n \t\t\r\n \t}\r\n \t\r\n \t// Print both the top and bottom circular faces\r\n \tfor( int i = 0; i < radialDivisions; i ++ )\r\n \t{\r\n \t\tthis.addTriangle(midTop.x, midTop.y, midTop.z, upper[i + 1].x, upper[i + 1].y, upper[i + 1].z, upper[i].x, upper[i].y, upper[i].z);\r\n \t}\r\n \t\r\n \tfor( int i = 0; i < radialDivisions; i ++ )\r\n \t{\r\n \t\tthis.addTriangle(midBot.x, midBot.y, midBot.z, lower[i].x, lower[i].y, lower[i].z, lower[i + 1].x, lower[i + 1].y, lower[i + 1].z);\r\n \t}\r\n \t\r\n \t\r\n \t\r\n \t// Curved Surface\r\n \tfloat v = -0.5f;\r\n \t\r\n \tfloat vert[] = new float[heightDivisions + 1];\r\n \t\r\n \tfor( int i = 0; i <= heightDivisions; i++)\r\n \t{\r\n \t\tvert[i] = v;\r\n \t\tv = v + (float)(1/(float)heightDivisions);\r\n \t}\r\n \t\r\n \t// Display the curved surface faces\r\n \tfor( int j = 0; j < heightDivisions; j ++ )\r\n \t\tfor(int k = 0; k < radialDivisions; k ++ )\r\n \t\t{\r\n \t\t\tif( k == radialDivisions - 1 )\r\n \t\t\t{\r\n \t\t\t\tPoint tempP1 = new Point(lower[k].x, vert[j], lower[k].z);\r\n \t\t\t\tPoint tempP2 = new Point(lower[0].x, vert[j], lower[0].z);\r\n \t\t\t\tPoint tempP3 = new Point(lower[0].x, vert[j + 1], lower[0].z);\r\n \t\t\t\tPoint tempP4 = new Point(lower[k].x, vert[j + 1], lower[k].z);\r\n \t\t\t\t\r\n \t\t\t\taddTriangle(tempP1.x, tempP1.y, tempP1.z, tempP4.x, tempP4.y, tempP4.z, tempP3.x, tempP3.y, tempP3.z );\r\n \t\t\taddTriangle(tempP1.x, tempP1.y, tempP1.z, tempP3.x, tempP3.y, tempP3.z, tempP2.x, tempP2.y, tempP2.z);\r\n \t\t\t}\r\n \t\t\telse\r\n \t\t\t{\r\n \t\t\t\tPoint tempP1 = new Point(lower[k].x, vert[j], lower[k].z);\r\n \t\t\t\tPoint tempP2 = new Point(lower[k + 1].x, vert[j], lower[k + 1].z);\r\n \t\t\t\tPoint tempP3 = new Point(lower[k + 1].x, vert[j + 1], lower[k + 1].z);\r\n \t\t\t\tPoint tempP4 = new Point(lower[k].x, vert[j + 1], lower[k].z);\r\n \t\t\t\t\r\n \t\t\t\taddTriangle(tempP1.x, tempP1.y, tempP1.z, tempP4.x, tempP4.y, tempP4.z, tempP3.x, tempP3.y, tempP3.z );\r\n \t\t\taddTriangle(tempP1.x, tempP1.y, tempP1.z, tempP3.x, tempP3.y, tempP3.z, tempP2.x, tempP2.y, tempP2.z);\r\n \t\t\t}\r\n \t\t}\r\n }","public void DrawCylinder(float radius, float height, int nSegments ) \n\t{\n\t\tGL11.glBegin(GL11.GL_TRIANGLES);\n\t\tPoint4f point4f7 = new Point4f();\n\t\tPoint4f point4f8 = new Point4f(0.0f, 0.0f, 1.0f, 0.0f);\n\t\tfor(float i=0.0f; i < nSegments; i += 1.0f) {\n\t\t\t//First, the origin is located at the center of the circle below. First, draw the triangle above the side.\n\t\t\tfloat angle = (float)Math.PI * i * 2.0f / nSegments;\n\t\t\tfloat nextAngle = (float)Math.PI * (i + 1.0f) * 2.0f / nSegments;\n\t\t\tfloat x1 = (float)Math.sin((double)angle)*radius, y1 = (float)Math.cos((double)angle)*radius;\n\t\t\tfloat x2 = (float)Math.sin((double)nextAngle)*radius, y2 = (float)Math.cos((double)nextAngle)*radius;\n\n\t\t\tPoint4f point4f1 = new Point4f(x1, y1, 0.0f, 0.0f);\n\t\t\tPoint4f point4f2 = new Point4f(x2, y2, 1.0f, 0.0f);\n\t\t\tPoint4f point4f3 = new Point4f(x1, y1, 1.0f, 0.0f);\n\t\t\tVector4f v = point4f2.MinusPoint(point4f1);\n\t\t\tVector4f w = point4f3.MinusPoint(point4f1);\n\t\t\tVector4f normal = v.cross(w).Normal();\n//\t\t\tGL11.glNormal3f( normal.x, normal.y, normal.z);\n\t\t\tGL11.glNormal3f( x1, y1, 0.0f);\n\t\t\tGL11.glVertex3f(x1, y1, 0.0f);\n\t\t\tGL11.glNormal3f( x2, y2, height);\n GL11.glVertex3f(x2, y2, height);\n GL11.glNormal3f( x1, y1, height);\n GL11.glVertex3f(x1, y1, height);\n \n //Draw the triangle on top of the lid according to the triangle on top of the side.\n Vector4f v2 = point4f2.MinusPoint(point4f8);\n Vector4f w2 = point4f3.MinusPoint(point4f8);\n Vector4f normal2 = v2.cross(w2).Normal();\n GL11.glNormal3f( normal2.x, normal2.y, normal2.z);\n GL11.glVertex3f(0.0f, 0.0f, height);\n GL11.glVertex3f(x2, y2, height);\n GL11.glVertex3f(x1, y1, height);\n \n //Draw the triangle below the sides.\n Point4f point4f4 = new Point4f(x1, y1, 0.0f, 0.0f);\n\t\t\tPoint4f point4f5 = new Point4f(x2, y2, 0.0f, 0.0f);\n\t\t\tPoint4f point4f6 = new Point4f(x1, y1, 1.0f, 0.0f);\n\t\t\tVector4f v1 = point4f5.MinusPoint(point4f4);\n\t\t\tVector4f w1 = point4f6.MinusPoint(point4f4);\n\t\t\tVector4f normal1 = v1.cross(w1).Normal();\n//\t\t\tGL11.glNormal3f( normal1.x, normal1.y, normal1.z);\n\t\t\tGL11.glNormal3f( x1, y1, 0.0f);\n\t\t\tGL11.glVertex3f(x1, y1, 0.0f);\n\t\t\tGL11.glNormal3f( x2, y2, 0.0f);\n GL11.glVertex3f(x2, y2, 0.0f);\n GL11.glNormal3f( x2, y2, height);\n GL11.glVertex3f(x2, y2, height);\n \n //Draw the triangle on the lower lid according to the triangle below the side.\n Vector4f v3 = point4f4.MinusPoint(point4f7);\n Vector4f w3 = point4f5.MinusPoint(point4f7);\n Vector4f normal3 = v3.cross(w3).Normal();\n GL11.glNormal3f( normal3.x, normal3.y, normal3.z);\n GL11.glVertex3f(0.0f, 0.0f, 0.0f);\n GL11.glVertex3f(x2, y2, 0.0f);\n GL11.glVertex3f(x1, y1, 0.0f);\n\t\t}\n\t\tGL11.glEnd();\n\t}","public void makeCone (float radius, int radialDivisions, int heightDivisions)\r\n {\r\n \tPoint lower[][] = new Point[heightDivisions + 1][radialDivisions + 1];\r\n \t\r\n \tfloat rad[] = new float[heightDivisions + 1];\r\n \tfloat vert = -0.5f;\r\n \t\r\n \t// Calculate radius for every subdivision along the height\r\n \tfor(int i = 0; i < heightDivisions; i ++)\r\n \t{\r\n \t\trad[i] = radius * ( 1.0f - ( 1f /(float)heightDivisions) * i );\r\n \t}\r\n \t\r\n \t// Calculate curved surface vertices for every subdivision along the height\r\n \tfor(int i = 0; i <= heightDivisions; i ++ )\r\n \t{\r\n \t\tfor(int j = 0; j <= radialDivisions; j ++)\r\n \t\t{\r\n \t\t\tlower[i][j] = new Point();\r\n \t\t\tlower[i][j].x = rad[i] * (float)Math.cos(Math.toRadians ( (360.0f / (float)radialDivisions) * j ) );\r\n \t\t\tlower[i][j].z = rad[i] * (float)Math.sin(Math.toRadians ( (360.0f / (float)radialDivisions) * j ) );\r\n \t\t\tlower[i][j].y = vert;\r\n \t\t}\r\n \t\t// Update the y coordinate for next iteration\r\n \t\tvert += (1f / (float)heightDivisions);\r\n \t}\r\n \t\r\n \tvert = -0.5f;\r\n \t\r\n \t// Print the bottom circular surface\r\n \tfor(int i = 0; i <= radialDivisions - 1; i ++)\r\n \t{\r\n \t\tthis.addTriangle(lower[0][i].x, vert, lower[0][i].z, 0f, vert, 0f, lower[0][i+1].x, vert, lower[0][i+1].z );\r\n \t}\r\n \t\r\n \t// Print the curved surface\r\n \tfor(int i = 0 ; i < heightDivisions; i++)\r\n \t\tfor(int j = 0 ; j < radialDivisions; j++)\r\n \t\t{\r\n \t\t\tthis.addTriangle(lower[i][j].x, lower[i][j].y, lower[i][j].z, lower[i][j+1].x, lower[i][j+1].y, lower[i][j+1].z, lower[i+1][j+1].x, lower[i+1][j+1].y, lower[i+1][j+1].z);\r\n \t\t\tthis.addTriangle(lower[i][j].x, lower[i][j].y, lower[i][j].z, lower[i+1][j+1].x, lower[i+1][j+1].y, lower[i+1][j+1].z, lower[i+1][j].x, lower[i+1][j].y, lower[i+1][j].z);\r\n \t\t\t\r\n \t\t}\r\n }","private void generateSphere() {\n\t\tint segments = 14;\n\t\tint rings = 15; // Use an odd number of rings of faces so that halfway up the sphere is the middle of a ring and not a loop of edges\n\t\tverts = new Vector[segments * (rings - 1) + 2]; // There are rings + 1 rings of vertices, but the first and last of these are each a single vertex\n\t\tfaces = new int[2 * segments * (rings - 1)][3]; // Apart from the first and last, each ring has segments number of square faces, so 2 * segments triangular faces. The first and last each have segments triangular faces\n\t\tverts[0] = new Vector(3);\n\t\tverts[0].setElement(1, -1); // The lowest point of the sphere\n\t\tfor (int i = 0; i < segments; i++) {\n\t\t\tif (i == segments - 1) {\n\t\t\t\tfaces[i] = new int[] {0, i + 1, 1}; // The last face involves the last vertex in the second ring and loops back to the first vertex in the second ring\n\t\t\t} else {\n\t\t\t\tfaces[i] = new int[] {0, i + 1, i + 2}; // Triangles involving the lowest vertex and two consecutive vertices in the second ring of vertices\n\t\t\t}\n\t\t}\n\t\tdouble pitchIncrement = Math.PI / rings; // The increment in pitch (angle above horizontal) between rings of vertices\n\t\tdouble pitch = pitchIncrement - Math.PI / 2; // The lowest point had a pitch of -pi/2\n\t\tdouble headingIncrement = Math.PI * 2.0 / segments; // The increment in heading between segments\n\t\tdouble heading = -Math.PI;\n\t\tfor (int r = 0; r < rings - 1; r++) { // Last ring is a single point and must be treated separately\n\t\t\tdouble y = Math.sin(pitch); // The y co-ordinate for each vertex in this ring\n\t\t\tdouble modulus = Math.cos(pitch); // The radius of the circle which this ring lies on\n\t\t\tfor (int s = 0; s < segments; s++) {\n\t\t\t\tdouble x = modulus * Math.cos(heading); // x co-ordinate for the next vertex\n\t\t\t\tdouble z = modulus * Math.sin(heading); // z co-ordinate for the next vertex\n\t\t\t\tverts[segments * r + s + 1] = new Vector(3);\n\t\t\t\tverts[segments * r + s + 1].setElements(new double[] {x, y, z});\n\t\t\t\theading += headingIncrement;\n\t\t\t}\n\t\t\t// Make faces between the vertices just added and the next ring of vertices to be added\n\t\t\tif (r != rings - 2) { // The second to last ring doesn't make faces with the next ring up in the same way because the last ring is a single vertex\n\t\t\t\tfor (int i = 0; i < segments; i++) {\n\t\t\t\t\tif (i == segments - 1) { // The last two faces make use of the first vertex in the next ring by looping back to the start\n\t\t\t\t\t\t// Two faces in the same plane\n\t\t\t\t\t\tfaces[i * 2 + segments * (2 * r + 1)] = new int[] {segments * r + i + 1, (segments * r + i + 1) + segments, segments * r + 1 + segments};\n\t\t\t\t\t\tfaces[i * 2 + segments * (2 * r + 1) + 1] = new int[] {segments * r + i + 1, segments * r + 1 + segments, segments * r + 1};\n\t\t\t\t\t} else {\n\t\t\t\t\t\t// Two faces that are in the same plane and appear as a quadrilateral\n\t\t\t\t\t\tfaces[i * 2 + segments * (2 * r + 1)] = new int[] {segments * r + i + 1, (segments * r + i + 1) + segments, (segments * r + i + 1) + segments + 1};\n\t\t\t\t\t\tfaces[i * 2 + segments * (2 * r + 1) + 1] = new int[] {segments * r + i + 1, (segments * r + i + 1) + segments + 1, (segments * r + i + 1) + 1};\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t\tpitch += pitchIncrement;\n\t\t}\n\t\tverts[verts.length - 1] = new Vector(3);\n\t\tverts[verts.length - 1].setElement(1, 1); // The last and highest vertex\n\t\tfor (int i = 0; i < segments; i++) {\n\t\t\tif (i == segments - 1) { // Last face completes the ring and includes the last vertex of the second to last ring\n\t\t\t\tfaces[2 * segments + segments * (2 * rings - 5) + i] = new int[] {segments * (rings - 2) + 1 + i, segments * (rings - 1) + 1, segments * (rings - 2) + 1};\n\t\t\t} else { // Faces involving the last vertex and two consecutive vertices in the second to last ring\n\t\t\t\tfaces[2 * segments + segments * (2 * rings - 5) + i] = new int[] {segments * (rings - 2) + 1 + i, segments * (rings - 1) + 1, segments * (rings - 2) + 1 + i + 1};\n\t\t\t}\n\t\t}\n\t}","private void generatePrism() {\n\t\tdouble halfAltitude = Math.sin(Math.PI / 3); // The cross-section is an equilateral triangle with sides of length 2 units. The altitude is the height of the triangle with one edge horizontal\n\t\tverts = new Vector[] {new Vector(3), new Vector(3), new Vector(3), new Vector(3), new Vector(3), new Vector(3)};\n\t\tverts[0].setElements(new double[] {-1, -halfAltitude, -1});\n\t\tverts[1].setElements(new double[] {0, halfAltitude, -1});\n\t\tverts[2].setElements(new double[] {1, -halfAltitude, -1});\n\t\t// Use the same triangle of vertices but offset by 2 units along the z-axis\n\t\tverts[3].setElements(verts[0]);\n\t\tverts[4].setElements(verts[1]);\n\t\tverts[5].setElements(verts[2]);\n\t\tverts[3].setElement(2, 1);\n\t\tverts[4].setElement(2, 1);\n\t\tverts[5].setElement(2, 1);\n\t\t\n\t\tfaces = new int[][] {{0, 1, 2}, {0, 5, 3}, {0, 2, 5}, {0, 3, 4}, {0, 4, 1}, {1, 4, 5}, {1, 5, 2}, {3, 5, 4}};\n\t}","public void makeCube (int subdivisions)\r\n {\r\n \tfloat horz[] = new float[subdivisions + 1];\r\n \tfloat vert[] = new float[subdivisions + 1];\r\n \t\r\n \t\r\n \t// Front face\r\n \tPoint p1 = new Point(-0.5f, -0.5f, 0.5f);\r\n \tPoint p2 = new Point(0.5f, -0.5f, 0.5f);\r\n \tPoint p3 = new Point(0.5f, 0.5f, 0.5f);\r\n \tPoint p4 = new Point(-0.5f, 0.5f, 0.5f);\r\n \t\r\n \tfloat h = p1.x;\r\n \tfloat v = p1.y;\r\n \t\r\n \tfor( int i = 0; i <= subdivisions; i++ )\r\n \t{\r\n \t\thorz[i] = h;\r\n \t\th = h + (float)(1/(float)subdivisions);\r\n \t}\r\n \t\r\n \tfor( int i = 0; i <= subdivisions; i++)\r\n \t{\r\n \t\tvert[i] = v;\r\n \t\tv = v + (float)(1/(float)subdivisions);\r\n \t}\r\n \t\r\n \tfor( int j = 0; j < vert.length - 1; j ++)\r\n \t\tfor( int k = 0; k < horz.length - 1; k ++)\r\n \t\t{\r\n \t\t\tPoint tempP1 = new Point(horz[k], vert[j], 0.5f);\r\n \t\t\tPoint tempP2 = new Point(horz[k + 1], vert[j], 0.5f);\r\n \t\t\tPoint tempP3 = new Point(horz[k + 1], vert[j + 1], 0.5f);\r\n \t\t\tPoint tempP4 = new Point(horz[k], vert[j + 1], 0.5f);\r\n \t\t\t\r\n \t\t\taddTriangle(tempP1.x, tempP1.y, tempP1.z, tempP3.x, tempP3.y, tempP3.z, tempP4.x, tempP4.y, tempP4.z);\r\n \t\t\taddTriangle(tempP1.x, tempP1.y, tempP1.z, tempP2.x, tempP2.y, tempP2.z, tempP3.x, tempP3.y, tempP3.z);\r\n \t\t\t\r\n \t\t}\r\n \t\r\n \t// Back face\r\n \tp1.y = p1.z = -0.5f;\r\n \tp1.x = 0.5f;\r\n \tp2.x = p2.y = p2.z = -0.5f;\r\n \tp3.x = p3.z = -0.5f;\r\n \tp3.y = 0.5f;\r\n \tp4.x = p4.y = 0.5f;\r\n \tp4.z = -0.5f;\r\n \t\r\n \th = p1.x;\r\n \tv = p1.y;\r\n \t\r\n \t\r\n \tfor( int i = 0; i <= subdivisions; i++ )\r\n \t{\r\n \t\thorz[i] = h;\r\n \t\th = h - (float)(1/(float)subdivisions);\r\n \t}\r\n \t\r\n \tfor( int i = 0; i <= subdivisions; i++)\r\n \t{\r\n \t\tvert[i] = v;\r\n \t\tv = v + (float)(1/(float)subdivisions);\r\n \t}\r\n \t\r\n \tfor( int j = 0; j < vert.length - 1; j ++)\r\n \t\tfor( int k = 0; k < horz.length - 1; k ++)\r\n \t\t{\r\n \t\t\tPoint tempP1 = new Point(horz[k], vert[j], -0.5f);\r\n \t\t\tPoint tempP2 = new Point(horz[k + 1], vert[j], -0.5f);\r\n \t\t\tPoint tempP3 = new Point(horz[k + 1], vert[j + 1], -0.5f);\r\n \t\t\tPoint tempP4 = new Point(horz[k], vert[j + 1], -0.5f);\r\n \t\t\t\r\n \t\t\taddTriangle(tempP1.x, tempP1.y, tempP1.z, tempP3.x, tempP3.y, tempP3.z, tempP4.x, tempP4.y, tempP4.z);\r\n \t\t\taddTriangle(tempP1.x, tempP1.y, tempP1.z, tempP2.x, tempP2.y, tempP2.z, tempP3.x, tempP3.y, tempP3.z);\r\n \t\t\t\r\n \t\t}\r\n \t\r\n \t// Left face\r\n \tp1.x = p1.y = p1.z = -0.5f;\r\n \tp2.x = p2.y = -0.5f;\r\n \tp2.z = 0.5f;\r\n \tp3.x = -0.5f;\r\n \tp3.y = p3.z = 0.5f;\r\n \tp4.y = 0.5f;\r\n \tp4.x = p4.z = -0.5f;\r\n \t\r\n \th = p1.z;\r\n \tv = p1.y;\r\n \t\r\n \t\r\n \tfor( int i = 0; i <= subdivisions; i++ )\r\n \t{\r\n \t\thorz[i] = h;\r\n \t\th = h + (float)(1/(float)subdivisions);\r\n \t}\r\n \t\r\n \tfor( int i = 0; i <= subdivisions; i++)\r\n \t{\r\n \t\tvert[i] = v;\r\n \t\tv = v + (float)(1/(float)subdivisions);\r\n \t}\r\n \t\r\n \tfor( int j = 0; j < vert.length - 1; j ++)\r\n \t\tfor( int k = 0; k < horz.length - 1; k ++)\r\n \t\t{\r\n \t\t\tPoint tempP1 = new Point(-0.5f, vert[j], horz[k]);\r\n \t\t\tPoint tempP2 = new Point(-0.5f, vert[j], horz[k + 1]);\r\n \t\t\tPoint tempP3 = new Point(-0.5f, vert[j + 1], horz[k + 1]);\r\n \t\t\tPoint tempP4 = new Point(-0.5f, vert[j + 1], horz[k]);\r\n \t\t\t\r\n \t\t\taddTriangle(tempP1.x, tempP1.y, tempP1.z, tempP3.x, tempP3.y, tempP3.z, tempP4.x, tempP4.y, tempP4.z);\r\n \t\t\taddTriangle(tempP1.x, tempP1.y, tempP1.z, tempP2.x, tempP2.y, tempP2.z, tempP3.x, tempP3.y, tempP3.z);\r\n \t\t\t\r\n \t\t}\r\n \t\r\n \t// Right face\r\n \tp1.x = p1.z = 0.5f;\r\n \tp1.y = -0.5f;\r\n \tp2.y = p2.z = -0.5f;\r\n \tp2.x = 0.5f;\r\n \tp3.x = p3.y = 0.5f;\r\n \tp3.z = -0.5f;\r\n \tp4.x = p4.y = p4.z = 0.5f;\r\n \t\r\n \t\r\n \th = p1.z;\r\n \tv = p1.y;\r\n \t\r\n \t\r\n \tfor( int i = 0; i <= subdivisions; i++ )\r\n \t{\r\n \t\thorz[i] = h;\r\n \t\th = h - (float)(1/(float)subdivisions);\r\n \t}\r\n \t\r\n \tfor( int i = 0; i <= subdivisions; i++)\r\n \t{\r\n \t\tvert[i] = v;\r\n \t\tv = v + (float)(1/(float)subdivisions);\r\n \t}\r\n \t\r\n \tfor( int j = 0; j < vert.length - 1; j ++)\r\n \t\tfor( int k = 0; k < horz.length - 1; k ++)\r\n \t\t{\r\n \t\t\tPoint tempP1 = new Point(0.5f, vert[j], horz[k]);\r\n \t\t\tPoint tempP2 = new Point(0.5f, vert[j], horz[k + 1]);\r\n \t\t\tPoint tempP3 = new Point(0.5f, vert[j + 1], horz[k + 1]);\r\n \t\t\tPoint tempP4 = new Point(0.5f, vert[j + 1], horz[k]);\r\n \t\t\t\r\n \t\t\taddTriangle(tempP1.x, tempP1.y, tempP1.z, tempP3.x, tempP3.y, tempP3.z, tempP4.x, tempP4.y, tempP4.z);\r\n \t\t\taddTriangle(tempP1.x, tempP1.y, tempP1.z, tempP2.x, tempP2.y, tempP2.z, tempP3.x, tempP3.y, tempP3.z);\r\n \t\t\t\r\n \t\t}\r\n \t\r\n \t// Top face\r\n \tp1.x = -0.5f;\r\n \tp1.y = p1.z = 0.5f;\r\n \tp2.x = p2.y = p2.z = 0.5f;\r\n \tp3.x = p3.y = 0.5f;\r\n \tp3.z = -0.5f;\r\n \tp4.x = p4.z = -0.5f;\r\n \tp4.y = 0.5f;\r\n \t\r\n \t\r\n \th = p1.x;\r\n \tv = p1.z;\r\n \t\r\n \t\r\n \tfor( int i = 0; i <= subdivisions; i++ )\r\n \t{\r\n \t\thorz[i] = h;\r\n \t\th = h + (float)(1/(float)subdivisions);\r\n \t}\r\n \t\r\n \tfor( int i = 0; i <= subdivisions; i++)\r\n \t{\r\n \t\tvert[i] = v;\r\n \t\tv = v - (float)(1/(float)subdivisions);\r\n \t}\r\n \t\r\n \tfor( int j = 0; j < vert.length - 1; j ++)\r\n \t\tfor( int k = 0; k < horz.length - 1; k ++)\r\n \t\t{\r\n \t\t\tPoint tempP1 = new Point(horz[k], 0.5f, vert[j]);\r\n \t\t\tPoint tempP2 = new Point(horz[k + 1], 0.5f, vert[j]);\r\n \t\t\tPoint tempP3 = new Point(horz[k + 1], 0.5f, vert[j + 1]);\r\n \t\t\tPoint tempP4 = new Point(horz[k], 0.5f, vert[j + 1]);\r\n \t\t\t\r\n \t\t\taddTriangle(tempP1.x, tempP1.y, tempP1.z, tempP3.x, tempP3.y, tempP3.z, tempP4.x, tempP4.y, tempP4.z);\r\n \t\t\taddTriangle(tempP1.x, tempP1.y, tempP1.z, tempP2.x, tempP2.y, tempP2.z, tempP3.x, tempP3.y, tempP3.z);\r\n \t\t\t\r\n \t\t}\r\n \t\r\n \t// Bottom face\r\n \tp1.x = p1.y = p1.z = -0.5f;\r\n \tp2.y = p2.z = 0.5f;\r\n \tp2.x = 0.5f;\r\n \tp3.x = p3.z = 0.5f;\r\n \tp3.y = -0.5f;\r\n \tp4.x = p4.y = -0.5f;\r\n \tp4.z = 0.5f;\r\n \t\r\n \t\r\n \th = p1.x;\r\n \tv = p1.z;\r\n \t\r\n \t\r\n \tfor( int i = 0; i <= subdivisions; i++ )\r\n \t{\r\n \t\thorz[i] = h;\r\n \t\th = h + (float)(1/(float)subdivisions);\r\n \t}\r\n \t\r\n \tfor( int i = 0; i <= subdivisions; i++)\r\n \t{\r\n \t\tvert[i] = v;\r\n \t\tv = v + (float)(1/(float)subdivisions);\r\n \t}\r\n \t\r\n \tfor( int j = 0; j < vert.length - 1; j ++)\r\n \t\tfor( int k = 0; k < horz.length - 1; k ++)\r\n \t\t{\r\n \t\t\tPoint tempP1 = new Point(horz[k], -0.5f, vert[j]);\r\n \t\t\tPoint tempP2 = new Point(horz[k + 1], -0.5f, vert[j]);\r\n \t\t\tPoint tempP3 = new Point(horz[k + 1], -0.5f, vert[j + 1]);\r\n \t\t\tPoint tempP4 = new Point(horz[k], -0.5f, vert[j + 1]);\r\n \t\t\t\r\n \t\t\taddTriangle(tempP1.x, tempP1.y, tempP1.z, tempP3.x, tempP3.y, tempP3.z, tempP4.x, tempP4.y, tempP4.z);\r\n \t\t\taddTriangle(tempP1.x, tempP1.y, tempP1.z, tempP2.x, tempP2.y, tempP2.z, tempP3.x, tempP3.y, tempP3.z);\r\n \t\t\t\r\n \t\t}\r\n \t\r\n }","public Prism(int numSides, double radius, double height) {\n Vector3d toTop = new Vector3d(0.0, 0.0, height);\n double centralAngle = 2.0 * Math.PI / numSides;\n\n Face bottomFace = new Face(numSides);\n Face topFace = new Face(numSides);\n int vertexIndex = 0;\n for (int i = 0; i < numSides; i++) {\n double totalAngle = centralAngle * i;\n double x = radius * Math.cos(totalAngle);\n double y = radius * Math.sin(totalAngle);\n Vector3d bottomVertex = new Vector3d(x, y, -height / 2.0);\n\n Vector3d topVertex = new Vector3d();\n topVertex.add(bottomVertex, toTop);\n\n addVertexPositions(bottomVertex, topVertex);\n\n bottomFace.setVertexIndex(numSides - i - 1, vertexIndex);\n topFace.setVertexIndex(i, vertexIndex + 1);\n\n Face quad = new Face(4);\n int nextBottom = (vertexIndex + 2) % (2 * numSides);\n int nextTop = nextBottom + 1;\n quad.setAllVertexIndices(vertexIndex, nextBottom, nextTop,\n vertexIndex + 1);\n\n addFace(quad);\n\n vertexIndex += 2;\n }\n\n addFaces(bottomFace, topFace);\n\n setVertexNormalsToFaceNormals();\n }","public static DeformableMesh3D createRectangleMesh(double width, double height, double depth, double segment_size){\n ArrayList pts = new ArrayList();\n ArrayList connections = new ArrayList();\n ArrayList triangles = new ArrayList();\n //For the complete length there will be n+1 nodes\n int nx = (int)(width/segment_size + 0.5) + 1;\n int ny = (int)(height/segment_size+0.5) + 1;\n int nz = (int)(depth/segment_size+0.5) + 1;\n double actual_w = (nx-1)*segment_size;\n double actual_h = (ny-1)*segment_size;\n double actual_z = (nz-1)*segment_size;\n\n int dex;\n\n //top face x-y @ actual_z/2\n int top_starting_dex = pts.size();\n for(int i = 0; i0){\n connections.add(new int[]{\n dex,\n dex - ny\n });\n }\n\n if(j>0){\n connections.add(new int[]{\n dex,\n dex-1\n });\n }\n }\n }\n\n for(int i = 1; i0){\n connections.add(new int[]{\n dex,\n dex - ny\n });\n }\n\n if(j>0){\n connections.add(new int[]{\n dex,\n dex - 1\n });\n }\n\n\n }\n }\n //bottom face\n for(int i = 1; i0){\n //previous row\n connections.add(new int[]{\n dex,\n dex - (nz-2)\n });\n }\n\n if(j>1){\n //previous column\n connections.add(new int[]{\n dex,\n dex - 1\n });\n }\n }\n }\n\n\n //left face connections\n for(int i = 0; i0){\n //previous row\n connections.add(new int[]{\n dex,\n dex - (nz-2)\n });\n }\n\n if(j>1){\n //previous column\n connections.add(new int[]{\n dex,\n dex - 1\n });\n }\n }\n }\n\n for(int i = 0; i1){\n connections.add(new int[]{\n dex,\n dex - (nz-2)\n });\n }\n\n if(j>1){\n connections.add(new int[]{\n dex,\n dex - 1\n });\n }\n\n\n }\n }\n\n //connect to top and bottom.\n for(int i = 1; i1){\n connections.add(new int[]{\n dex,\n dex - (nz-2)\n });\n }\n\n if(j>1){\n connections.add(new int[]{\n dex,\n dex - 1\n });\n }\n\n\n }\n }\n\n\n //connect to top and bottom.\n for(int i = 1; i> findIntersections(Ray myRay) {\n public List FindIntersections(Ray myRay) {\n\n List geometryListMap = new ArrayList<>();\n List listOfIntersections = new ArrayList();\n\n // the bottom base of the cylinder\n Plane plane1 = new Plane(orientation.getPOO(), orientation.getDirection());\n\n // the top base of the cylinder\n Plane plane2 = new Plane(top, orientation.getDirection());\n\n List temp1 = plane1.FindIntersections(myRay);\n\n List temp2 = plane2.FindIntersections(myRay);\n\n // removing all points that beyond the radius\n if (temp1 != null)\n for (Point3D p1 : temp1) {\n if (new Vector(Point3D.substract(orientation.getPOO(), p1)).length() <= _radius && p1 != null)\n listOfIntersections.add(p1);\n\n }\n\n if (temp2 != null)\n for (Point3D p2 : temp2) {\n if (new Vector(Point3D.substract(orientation.getPOO(), p2)).length() <= _radius && p2 != null)\n listOfIntersections.add(p2);\n\n }\n\n // using the infinity cylinder to find all the intersections in the body of the limited cylinder\n geometryListMap = super.FindIntersections(myRay);\n\n for (Point3D p : geometryListMap) {\n if (isOnCylinder(p))\n listOfIntersections.add(p);\n\n }\n if (listOfIntersections.isEmpty())\n return null;\n //geometryListMap.put(this, listOfIntersections);\n return geometryListMap;\n }","private void generateCube() {\n\t\tverts = new Vector[] {new Vector(3), new Vector(3), new Vector(3), new Vector(3), new Vector(3), new Vector(3), new Vector(3), new Vector(3)};\n\t\tverts[0].setElement(0, -1);\n\t\tverts[0].setElement(1, -1);\n\t\tverts[0].setElement(2, -1);\n\t\t\n\t\tverts[1].setElement(0, 1);\n\t\tverts[1].setElement(1, -1);\n\t\tverts[1].setElement(2, -1);\n\t\t\n\t\tverts[2].setElement(0, -1);\n\t\tverts[2].setElement(1, -1);\n\t\tverts[2].setElement(2, 1);\n\t\t\n\t\tverts[3].setElement(0, 1);\n\t\tverts[3].setElement(1, -1);\n\t\tverts[3].setElement(2, 1);\n\t\t\n\t\tverts[4].setElement(0, -1);\n\t\tverts[4].setElement(1, 1);\n\t\tverts[4].setElement(2, -1);\n\t\t\n\t\tverts[5].setElement(0, 1);\n\t\tverts[5].setElement(1, 1);\n\t\tverts[5].setElement(2, -1);\n\t\t\n\t\tverts[6].setElement(0, -1);\n\t\tverts[6].setElement(1, 1);\n\t\tverts[6].setElement(2, 1);\n\t\t\n\t\tverts[7].setElement(0, 1);\n\t\tverts[7].setElement(1, 1);\n\t\tverts[7].setElement(2, 1);\n\t\t\n\t\tfaces = new int[][] {{0, 3, 2}, {0, 1, 3}, {0, 4, 5}, {0, 5, 1}, {0, 2, 6}, {0, 6, 4}, {2, 7, 6}, {2, 3, 7}, {3, 1, 5}, {3, 5, 7}, {4, 7, 5}, {4, 6, 7}}; // List the vertices of each face by index in verts. Vertices must be listed in clockwise order from outside of the shape so that the faces pointing away from the camera can be culled or shaded differently\n\t}","public void makeCone(float radius, int radialDivisions, int heightDivisions) {\n\t\t// System.out.println(\"ram\");\n\t\tif (radialDivisions < 3)\n\t\t\tradialDivisions = 3;\n\n\t\tif (heightDivisions < 1)\n\t\t\theightDivisions = 1;\n\n\t\tif (heightDivisions > 65)\n\t\t\theightDivisions = 65;\n\n\t\tif (radialDivisions > 65)\n\t\t\tradialDivisions = 65;\n\t//\tSystem.out.println(radialDivisions + \" \" + heightDivisions);\n\t\t// coordinates for the triangle formation\n\t\tfloat x1 = 0;\n\t\tfloat y1 = 0;\n\t\tfloat z1 = 0;\n\t\tfloat x2 = 0;\n\t\tfloat y2 = 0;\n\t\tfloat z2 = 0;\n\t\tfloat x3 = 0;\n\t\tfloat y3 = 0;\n\t\tfloat z3 = 0;\n\t\tfloat theta = (float) (2 * Math.PI / radialDivisions);\n\t\tfloat refy = -0.5f;\n\t\tfloat nexty = 1f / heightDivisions;\n\t\tfor (int rD = 0; rD < radialDivisions; rD++) {\n\t\t\t//defining coordinates of first point\n\t\t\tx1 = 0f;\n\t\t\ty1 = refy;\n\t\t\tz1 = 0f;\n\t\t\t//defining coordinates of second point\n\t\t\tx2 = (float) (radius * Math.cos(theta * rD));\n\t\t\ty2 = y1;\n\t\t\tz2 = -(float) (radius * Math.sin(theta * rD));\n\t\t\t//defining coordinates of third point\n\t\t\tx3 = (float) (radius * Math.cos(theta * (rD + 1)));\n\t\t\ty3 = y1;\n\t\t\tz3 = -(float) (radius * Math.sin(theta * (rD + 1)));\n\n\t\t\t// tessellation for circle\n\t\t\taddTriangle(x1, y1, z1, 0.0f, 0.0f, x2, y2, z2, 0.0f, 0.0f, x3, y3, z3, 0.0f, 0.0f);\n\n\t\t\t// tessellation for covering\n\t\t\tfor (int hD = 0; hD < heightDivisions; hD++) {\n\t\t\t\t//updating coordinates of first point\n\t\t\t\tx1 = (float) ((radius - (radius * hD / heightDivisions)) * Math\n\t\t\t\t\t\t.cos(theta * (rD + 1)));\n\t\t\t\ty1 = refy + (nexty * hD);\n\t\t\t\tz1 = -(float) ((radius - (radius * hD / heightDivisions)) * Math\n\t\t\t\t\t\t.sin(theta * (rD + 1)));\n\t\t\t\t//updating coordinates of first point\n\t\t\t\tx2 = (float) ((radius - (radius * hD / heightDivisions)) * Math\n\t\t\t\t\t\t.cos(theta * rD));\n\t\t\t\ty2 = refy + (nexty * hD);\n\t\t\t\tz2 = -(float) ((radius - (radius * hD / heightDivisions)) * Math\n\t\t\t\t\t\t.sin(theta * rD));\n\t\t\t\t//updating coordinates of first point\n\t\t\t\tx3 = (float) ((radius - (radius * (hD + 1) / heightDivisions)) * Math\n\t\t\t\t\t\t.cos(theta * rD));\n\t\t\t\ty3 = refy + (nexty * (hD + 1));\n\t\t\t\tz3 = -(float) ((radius - (radius * (hD + 1) / heightDivisions)) * Math\n\t\t\t\t\t\t.sin(theta * rD));\n\n\t\t\t\taddTriangle(x1, y1, z1, 0.0f, 0.0f, x2, y2, z2, 0.0f, 0.0f, x3, y3, z3, 0.0f, 0.0f);\n\t\t\t\t//updating coordinates of first point\n\t\t\t\tx1 = (float) ((radius - (radius * (hD + 1) / heightDivisions)) * Math\n\t\t\t\t\t\t.cos(theta * (rD + 1)));\n\t\t\t\ty1 = refy + (nexty * (hD + 1));\n\t\t\t\tz1 = -(float) ((radius - (radius * (hD + 1) / heightDivisions)) * Math\n\t\t\t\t\t\t.sin(theta * (rD + 1)));\n\t\t\t\t//updating coordinates of first point\n\t\t\t\tx2 = (float) ((radius - (radius * hD / heightDivisions)) * Math\n\t\t\t\t\t\t.cos(theta * (rD + 1)));\n\t\t\t\ty2 = refy + (nexty * hD);\n\t\t\t\tz2 = -(float) ((radius - (radius * hD / heightDivisions)) * Math\n\t\t\t\t\t\t.sin(theta * (rD + 1)));\n\n\t\t\t\taddTriangle(x1, y1, z1, 0.0f, 0.0f, x2, y2, z2, 0.0f, 0.0f, x3, y3, z3, 0.0f, 0.0f);\n\n\t\t\t}\n\n\t\t}\n\n\t}","public Cylinder(double height, double radius) {\n\t\tsuper();\n\t\tthis.height = height;\n\t\tthis.radius = radius;\n\t\tthis.center = false;\n\t}","public void calculate() {\n\t\t\n\t\tHashMap vertices = triangulation.getVertices();\n\t\tHashMap faces = triangulation.getFaces();\n\n\t\tHashMap chords = new HashMap();\n\t\tList onOuterCircle = new LinkedList();\n\t\tList outerCircle = new LinkedList();\n\n\t\tfor (Vertex v : vertices.values()) {\n\t\t\tchords.put(v.getId(), 0);\n\t\t\tchildren.put(v.getId(), new LinkedList());\n\t\t}\n\n\t\t// determine outer face (randomly, use the first face)\n\t\tFace outerFace = null;\n\t\tfor (Face f : faces.values()) {\n\t\t\touterFace = f;\n\t\t\tbreak;\n\t\t}\n\t\tif (outerFace == null) {\n\t\t\t// there are no faces at all in the embedding\n\t\t\treturn;\n\t\t}\n\n\t\tEdge e = outerFace.getIncidentEdge();\n\t\tvertexOrder[1] = e.getSource();\n\t\tvertexOrder[0] = e.getTarget();\n\t\tonOuterCircle.add(e.getTarget());\n\t\tonOuterCircle.add(e.getNext().getTarget());\n\t\tonOuterCircle.add(e.getSource());\n\t\touterCircle.add(e.getNext().getNext().getTwin());\n\t\touterCircle.add(e.getNext().getTwin());\n\t\t\n\t\t//System.out.println(\"outerCircle 0 \" + outerCircle.get(0).getId() + \" - source: \" + outerCircle.get(0).getSource().getId() + \" - target: \" + outerCircle.get(0).getTarget().getId());\n\t\t//System.out.println(\"outerCircle 1 \" + outerCircle.get(1).getId() + \" - source: \" + outerCircle.get(1).getSource().getId() + \" - target: \" + outerCircle.get(1).getTarget().getId());\n\t\t\n\n\t\tfor (int k=vertexOrder.length-1; k>1; k--) {\n\t\t\t//System.out.println(\"k: \" + k + \" - outerCircle size: \" + outerCircle.size());\n\t\t\t// chose v != v_0,v_1 such that v on outer face, not considered yet and chords(v)=0\n\t\t\tVertex nextVertex = null;\n\t\t\tint nextVertexId = -1;\n\t\t\tfor (int i=0; i childrenNextVertex = children.get(nextVertexId);\n\t\t\t\n\t\t\t// update edges of outer circle\n\t\t\tint index = 0;\n\t\t\t\n\t\t\twhile (outerCircle.get(index).getTarget().getId() != nextVertexId) {\n\t\t\t\tindex++;\n\t\t\t}\n\t\t\tEdge outofNextVertex = outerCircle.remove(index+1);\n\t\t\t\n\t\t\t\n\t\t\t//System.out.println(\"outOfNextVertex \" + outofNextVertex.getId() + \" - source: \" + outofNextVertex.getSource().getId() + \" - target: \" + outofNextVertex.getTarget().getId());\n\t\t\tEdge intoNextVertex = outerCircle.remove(index);\n\t\t\t//System.out.println(\"intoNextVertex \" + intoNextVertex.getId() + \" - source: \" + intoNextVertex.getSource().getId() + \" - target: \" + intoNextVertex.getTarget().getId());\n\t\t\tEdge current = intoNextVertex.getNext();\n\t\t\t//System.out.println(\"current \" + current.getId() + \" - source: \" + current.getSource().getId() + \" - target: \" + current.getTarget().getId());\n\t\t\t\n\t\t\tint endIndex = index;\n\t\t\t\n\t\t\twhile (current.getId() != outofNextVertex.getId()) {\n\t\t\t\tEdge onCircle = current.getNext().getTwin();\n\t\t\t\touterCircle.add(endIndex, onCircle);\n\t\t\t\t\n\t\t\t\tchildrenNextVertex.add(0, onCircle.getSource().getId());\n\t\t\t\t\n\t\t\t\tendIndex++;\n\t\t\t\tcurrent = current.getTwin().getNext();\n\t\t\t\tonOuterCircle.add(onCircle.getTarget());\n\t\t\t}\n\t\t\t\n\t\t\tEdge lastEdge = outofNextVertex.getNext().getTwin();\n\t\t\touterCircle.add(endIndex, lastEdge);\n\t\t\t\n\t\t\tchildrenNextVertex.add(0, lastEdge.getSource().getId());\n\t\t\tchildrenNextVertex.add(0, lastEdge.getTarget().getId());\n\n\t\t\t// update chords\n\t\t\tfor (Vertex v : onOuterCircle) {\n\t\t\t\tEdge incidentEdge = v.getOutEdge();\n\t\t\t\tint firstEdgeId = incidentEdge.getId();\n\t\t\t\tint chordCounter = -2; // the 2 neighbours are on the outer circle, but no chords\n\t\t\t\tdo {\n\t\t\t\t\tif (onOuterCircle.contains(incidentEdge.getTarget())) {\n\t\t\t\t\t\tchordCounter++;\n\t\t\t\t\t}\n\t\t\t\t\tincidentEdge = incidentEdge.getTwin().getNext();\n\t\t\t\t} while (incidentEdge.getId() != firstEdgeId);\n\t\t\t\tchords.put(v.getId(), chordCounter);\n\t\t\t}\n\t\t}\n\t}","public TriangleBumper(Double x,Double y,Double orientation,ListtriggeredGadgets){\n this.x = x;\n this.y = y;\n this.collideCirc = new ArrayList(); //corner that ball will collide with\n this.collideLine = new ArrayList(); //side that ball will collide with\n this.orientation = orientation;\n this.triggeredGadgets = new ArrayList<>();\n for (Gadget gadget : triggeredGadgets){\n this.triggeredGadgets.add(gadget);\n }\n //circle at each corner\n //line segment at each side\n if(this.orientation == 0.0){\n this.circles = Arrays.asList(new Circle(x,y,0.0), new Circle(x, y+1, 0.0), new Circle(x+1, y, 0.0));\n this.lines = Arrays.asList(new LineSegment(x+1, y, x, y+1), new LineSegment(x, y, x, y+1), new LineSegment(x,y, x+1, y));\n }else if (this.orientation == 90.0){\n this.circles = Arrays.asList(new Circle(x,y,0.0), new Circle(x+1, y, 0.0), new Circle(x+1, y+1,0.0));\n this.lines = Arrays.asList(new LineSegment(x, y, x+1, y), new LineSegment(x+1, y, x+1, y+1), new LineSegment(x,y, x+1, y+1));\n }else if (this.orientation == 180.0){\n this.circles = Arrays.asList(new Circle(x,y+1, 0.0), new Circle(x+1, y, 0.0), new Circle(x+1, y+1, 0.0));\n this.lines = Arrays.asList(new LineSegment(x, y+1, x+1, y), new LineSegment(x+1, y, x+1, y+1), new LineSegment(x+1, y+1, x, y+1));\n }else{\n this.circles = Arrays.asList(new Circle(x,y,0.0), new Circle(x, y+1, 0.0), new Circle(x+1, y+1, 0.0));\n this.lines = Arrays.asList(new LineSegment(x,y,x, y+1), new LineSegment(x,y+1, x+1, y+1), new LineSegment(x+1, y+1, x, y));\n }\n checkRep();\n\n }","@Override\r\n public Shape createShape(RenderContext ctx) {\n float v[] = { -1, -1, 1, 1, -1, 1, 1, 1, 1, -1, 1, 1, // front face\r\n -1, -1, -1, -1, -1, 1, -1, 1, 1, -1, 1, -1, // left face\r\n -1, -1, 1, -1, -1, -1, 1, -1, -1, 1, -1, 1 }; // bottom face\r\n\r\n // The vertex normals\r\n float n[] = { 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, // front face\r\n -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, // left face\r\n 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0 }; // bottom face\r\n\r\n // The vertex colors\r\n float c[] = { 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, //\r\n 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, //\r\n 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1 };\r\n\r\n // Texture coordinates\r\n float uv[] = { 0, 0, 1, 0, 1, 1, 0, 1, //\r\n 0, 0, 1, 0, 1, 1, 0, 1, //\r\n 0, 0, 1, 0, 1, 1, 0, 1 };\r\n\r\n // The triangles (three vertex indices for each triangle)\r\n int indices[] = { 0, 2, 3, 0, 1, 2, // front face\r\n 4, 6, 7, 4, 5, 6, // left face\r\n 8, 10, 11, 8, 9, 10 }; // bottom face\r\n\r\n // Construct a data structure that stores the vertices, their\r\n // attributes, and the triangle mesh connectivity\r\n VertexData vertexData = ctx.makeVertexData(12);\r\n vertexData.addElement(c, VertexData.Semantic.COLOR, 3);\r\n vertexData.addElement(v, VertexData.Semantic.POSITION, 3);\r\n vertexData.addElement(n, VertexData.Semantic.NORMAL, 3);\r\n vertexData.addElement(uv, VertexData.Semantic.TEXCOORD, 2);\r\n vertexData.addIndices(indices);\r\n\r\n return new jrtr.Shape(vertexData);\r\n }","private void setGeometryData() {\n // allocate vertices\n final int factorK = (innerRadius == 0 ? 1 : 2);\n final int verts = factorK * ((zSamples - 2) * (radialSamples) + 2); // rs + 1\n setVertexCoordsSize (verts);\n setNormalCoordsSize (verts);\n\n // generate geometry\n final double fInvRS = 1.0 / (radialSamples);\n final double fZFactor = 1.0 / (zSamples - 1); // 2.0 / (zSamples - 1);\n\n // Generate points on the unit circle to be used in computing the mesh\n // points on a sphere slice.\n final double[] afSin = new double[(radialSamples + 1)];\n final double[] afCos = new double[(radialSamples + 1)];\n for ( int iR = 0; iR < radialSamples; iR++ ) {\n final double fAngle = phi0 + dPhi * fInvRS * iR;\n afCos[iR] = Math.cos (fAngle);\n afSin[iR] = Math.sin (fAngle);\n }\n // afSin[radialSamples] = afSin[0];\n // afCos[radialSamples] = afCos[0];\n\n double radDiff = Math.abs (outerRadius - innerRadius);\n\n for ( int icnt = 0; icnt < 2; icnt++ ) {\n radius = (icnt == 0 ? innerRadius : outerRadius);\n if ( radius == 0.0 ) {\n continue;\n }\n double zNP = centerZ; // 0.0;\n double zSP = centerZ; // 0.0;\n\n // generate the sphere itself\n int i = 0;\n Vector3D tempVa;\n Vector3D kSliceCenter;\n\n for ( int iZ = 1; iZ < (zSamples - 1); iZ++ ) { // -1\n //final double fAFraction = 0.5 * Math.PI * (-1.0f + fZFactor * iZ); // in (-pi/2, pi/2)\n final double fAFraction = theta1 - iZ * fZFactor * dTheta;\n final double fZFraction = Math.sin (fAFraction); // in (-1,1)\n final double fZ = radius * fZFraction;\n\n // compute center of slice\n kSliceCenter = new Vector3D (\n center.getX (),\n center.getY (),\n center.getZ () + fZ\n );\n\n // compute radius of slice\n final double fSliceRadius = Math.sqrt (\n Math.abs (\n radius * radius - fZ * fZ\n )\n );\n\n // compute slice vertices with duplication at end point\n Vector3D kNormal;\n final int iSave = i;\n for ( int iR = 0; iR < radialSamples; iR++ ) {\n final double fRadialFraction = iR * fInvRS; // in [0,1)\n final Vector3D kRadial = new Vector3D (\n afCos[iR],\n afSin[iR],\n 0\n );\n tempVa = new Vector3D (\n fSliceRadius * kRadial.getX (),\n fSliceRadius * kRadial.getY (),\n fSliceRadius * kRadial.getZ ()\n );\n\n zNP = Math.\n max (kSliceCenter.getZ (), zNP);\n zSP = Math.\n min (kSliceCenter.getZ (), zSP);\n\n putVertex (\n (kSliceCenter.getX () + tempVa.getX ()),\n (kSliceCenter.getY () + tempVa.getY ()),\n (kSliceCenter.getZ () + tempVa.getZ ())\n );\n tempVa = getVertexCoord (i);\n\n kNormal = new Vector3D (\n tempVa.getX () - center.getX (),\n tempVa.getY () - center.getY (),\n tempVa.getZ () - center.getZ ()\n );\n double mag = Math.sqrt (\n Math.pow (kNormal.getX (), 2) +\n Math.pow (kNormal.getY (), 2) +\n Math.pow (kNormal.getZ (), 2)\n );\n kNormal = new Vector3D (\n kNormal.getX () / mag,\n kNormal.getY () / mag,\n kNormal.getZ () / mag\n );\n if ( !viewInside ) {\n putNormal (\n kNormal.getX (),\n kNormal.getY (),\n kNormal.getZ ()\n );\n } else {\n putNormal (\n -kNormal.getX (),\n -kNormal.getY (),\n -kNormal.getZ ()\n );\n }\n i++;\n }\n\n// setVertexCoord(i, getVertexCoord(iSave));\n// setNormalCoord(i, getNormalCoord(iSave));\n putVertex (getVertexCoord (iSave));\n putNormal (getNormalCoord (iSave));\n i++;\n }\n\n // south pole\n if ( theta0 == -0.5 * Math.PI ) {\n putVertex (new Vector3D (\n center.getX (),\n center.getY (),\n (center.getZ () - radius)\n ));\n setVertexCount (i + 1);\n if ( !viewInside ) {\n putNormal (new Vector3D (0, 0, -1));\n } else {\n putNormal (new Vector3D (0, 0, 1));\n }\n setNormalCount (i + 1);\n i++;\n }\n\n // north pole\n if ( theta1 == 0.5 * Math.PI ) {\n putVertex (new Vector3D (\n center.getX (),\n center.getY (),\n center.getZ () + radius\n ));\n setVertexCount (i + 1);\n if ( !viewInside ) {\n putNormal (new Vector3D (0, 0, 1));\n } else {\n putNormal (new Vector3D (0, 0, -1));\n }\n setNormalCount (i + 1);\n i++;\n }\n }\n\n }","public Cylinder(double radius, double height) {\n\t\tthis.base = new Circle(radius);\n\t\tthis.height = height;\n\t}","public static DeformableMesh3D createTestBlock(double w, double h, double depth){\n ArrayList pts = new ArrayList();\n ArrayList connections = new ArrayList();\n ArrayList triangles = new ArrayList();\n\n pts.add(new double[]{-w/2, -h/2, depth/2});\n pts.add(new double[]{-w/2, h/2, depth/2});\n pts.add(new double[]{w/2, h/2, depth/2});\n pts.add(new double[]{w/2, -h/2, depth/2});\n\n pts.add(new double[]{-w/2, -h/2, -depth/2});\n pts.add(new double[]{-w/2, h/2, -depth/2});\n pts.add(new double[]{w/2, h/2, -depth/2});\n pts.add(new double[]{w/2, -h/2, -depth/2});\n\n //back face\n connections.add(new int[]{0, 4});\n connections.add(new int[]{0, 1});\n connections.add(new int[]{1, 5});\n connections.add(new int[]{5, 4});\n\n //front face\n connections.add(new int[]{3, 7});\n connections.add(new int[]{2, 3});\n connections.add(new int[]{2, 6});\n connections.add(new int[]{6, 7});\n\n //front-back connections.\n connections.add(new int[]{3, 0});\n connections.add(new int[]{1, 2});\n connections.add(new int[]{5, 6});\n connections.add(new int[]{7, 4});\n\n //top\n triangles.add(new int[]{0, 2, 1});\n triangles.add(new int[]{0,3,2});\n //top-diagonal\n connections.add(new int[]{0, 2});\n\n //back\n triangles.add(new int[]{0, 1, 5});\n triangles.add(new int[]{0,5,4});\n connections.add(new int[]{0, 5});\n\n //right\n triangles.add(new int[]{1,2,5});\n triangles.add(new int[]{5,2,6});\n connections.add(new int[]{5, 2});\n\n //front\n triangles.add(new int[]{2,3,6});\n triangles.add(new int[]{6,3,7});\n connections.add(new int[]{3, 6});\n\n //left\n triangles.add(new int[]{3,0,4});\n triangles.add(new int[]{3,4,7});\n connections.add(new int[]{3, 4});\n\n //bottom\n triangles.add(new int[]{4,5,6});\n triangles.add(new int[]{4,6,7});\n connections.add(new int[]{4, 6});\n return new DeformableMesh3D(pts, connections, triangles);\n\n }","private void BC_cylinder(Grid gr){\r\n int i, j, j1, j2;\r\n NSmax = (int)(500.0/dt); repL=0.1;\r\n // Boundary conditions of lower side of computational domain\r\n for(i = 0; i drawCylinder(Position origin, int radius, int height, boolean includeOrigin){\n\t\tList cylinder = new ArrayList();\n\t\tPosition pos = origin.get2DProjection();\n\t\tfor(int i = 0; i < height; i++){\n\t\t\tPosition sliceOrigin = vectorAdd(pos, scalarMultiply(Direction.UP.getPosVector(), i));\n\t\t\tList ring = drawCircle(sliceOrigin, i, true);\n\t\t\tcylinder.addAll(ring);\n\t\t}\n\t\tif(!includeOrigin){\n\t\t\tcylinder.remove(origin);\n\t\t}\n\t\treturn cylinder;\n\t}","Car(int x, int y) {\n // ASSIGN ALL PARAMETERS TO THE CAR CLASS GLOBAL VARIABLES HERE\n xCord = x;\n yCord = y;\n targetCord = 0;\n // CREATE CAR PSHAPE HERE\n // ATTEMPT TO CREATE A CAR-LOOKING-THING USING YOUR OWN VERTICES\n\n //front of car\n //let's slam a bunch of vertices down and hope.\n car = createShape();\n fullCar = createShape(GROUP);\n car.beginShape();\n car.vertex(0, 20);\n car.vertex(2, 10);\n car.vertex(2.25f, 9);\n car.vertex(3, 7);\n car.vertex(4, 5);\n car.vertex(5, 3);\n car.vertex(6, 2);\n car.vertex(7, 1);\n car.vertex(8, .33f);\n car.vertex(9, .1f);\n car.vertex(10, 0);\n car.vertex(20, 0);\n\n car.vertex(21, .1f);\n car.vertex(22, .33f);\n car.vertex(23, 1);\n car.vertex(24, 2);\n car.vertex(25, 3);\n car.vertex(26, 5);\n car.vertex(27, 7);\n car.vertex(27.75f, 9);\n car.vertex(28, 10);\n car.vertex(30, 20);\n ////hood curve\n car.vertex(0, 20);\n car.vertex(0, 50);\n car.vertex(30, 50);\n car.vertex(30, 20);\n car.endShape(CLOSE);\n\n\n ////main body\n //have as three shape groups on top\n carTopLeft = createShape();\n carTopLeft.beginShape();\n carTopLeft.vertex(7, 24);\n carTopLeft.vertex(0, 50);\n carTopLeft.vertex(0, 20);\n carTopLeft.vertex(7, 24);\n carTopLeft.endShape(CLOSE);\n\n carTopRight = createShape();\n carTopRight.beginShape();\n carTopRight.vertex(23, 24);\n carTopRight.vertex(30, 50);\n carTopRight.vertex(30, 20);\n carTopRight.vertex(23, 24);\n carTopRight.endShape(CLOSE);\n\n carTop = createShape();\n carTop.beginShape();\n carTop.vertex(23, 24);\n\n carTop.vertex(15, 21);\n\n carTop.vertex(7, 24);\n carTop.vertex(0, 50);\n carTop.vertex(30, 50);\n carTop.vertex(23, 24);\n carTop.endShape(CLOSE);\n //car.vertex(23,24);\n //car.vertex(30,50);\n //car.vertex(30,20);\n //car.vertex(23,24);\n //car.vertex(22,23.25);\n //car.vertex(21,22.6);\n //car.vertex(20,22.1);\n //car.vertex(19,21.8);\n //car.vertex(18,21.4);\n //car.vertex(17,21.2);\n //car.vertex(16,21.1);\n //car.vertex(15,21);\n\n //car.vertex(14,21.1);\n //car.vertex(13,21.2);\n //car.vertex(12,21.4);\n //car.vertex(11,21.8);\n //car.vertex(10,22.1);\n //car.vertex(9,22.6);\n //car.vertex(8,23.25);\n //car.vertex(7,24);\n //car.vertex(0,50);\n //car.vertex(0,20);\n //car.vertex(7,24);\n //car.vertex(0,50);\n ////top details\n\n ////rear\n //test vertex\n carRear = createShape();\n carRear.beginShape();\n carRear.vertex(0, 50);\n carRear.vertex(0, 70);\n carRear.vertex(1, 71.2f);\n carRear.vertex(2, 72.33f);\n carRear.vertex(3, 73);\n carRear.vertex(4, 73.25f);\n carRear.vertex(5, 73.75f);\n carRear.vertex(6, 74);\n carRear.vertex(7, 74.2f);\n carRear.vertex(8, 74.4f);\n carRear.vertex(9, 74.6f);\n carRear.vertex(10, 74.8f);\n // carRear.vertex(11,74.85);\n // carRear.vertex(12,74.9);\n //carRear.vertex(14,74.95); \n carRear.vertex(15, 75);\n //carRear.vertex(16,74.95); \n //carRear.vertex(17,74.93);\n //carRear.vertex(18,74.9);\n carRear.vertex(19, 74.85f);\n carRear.vertex(20, 74.8f);\n carRear.vertex(21, 74.6f);\n carRear.vertex(22, 74.4f);\n carRear.vertex(23, 74.2f);\n carRear.vertex(24, 74);\n carRear.vertex(25, 73.75f);\n carRear.vertex(26, 73.25f);\n carRear.vertex(27, 73);\n carRear.vertex(28, 72.33f);\n carRear.vertex(29, 71.2f);\n carRear.vertex(30, 70);\n carRear.vertex(30, 50);\n carRear.endShape(CLOSE);\n //FINISH THE PSHAPE WITH YOUR CUSTOM VERTICES\n\n //it worked\n\n // ADD WHEELS TO THE CAR (ELLIPSES)\n //leftWheel = createShape(ELLIPSE, xCoord +10, yCoord + 25, 8, 8);\n // rightWheel = createShape(ELLIPSE, xCoord +45, yCoord + 25, 8, 8);\n\n //groups everything together\n fullCar.addChild(car);\n fullCar.addChild(carRear);\n fullCar.addChild(carTopLeft);\n fullCar.addChild(carTopRight);\n fullCar.addChild(carTop);\n // fullCar.addChild(leftWheel);\n // fullCar.addChild(rightWheel);\n }","static void createCubes(double width, double height) {\n \t\r\n \tmaxY=f(startingBound);\r\n \tmaxX=startingBound;\r\n \t\r\n \t//need a function to find the max\r\n \tfor(double i=startingBound; i<=endingBound; i=i+dx) {\r\n \t\tif(f(i)>maxY)\r\n \t\t\tmaxY=f(i);\r\n \t\t\r\n \t\tif(i>maxX)\r\n \t\t\tmaxX=i;\r\n \t}\r\n \tdouble size=height/2-100;\r\n \tSystem.out.println(size);\r\n \tscaleY=maxY/(size);\r\n \tscaleX=(width-100)/maxX;\r\n \t\r\n \tfor(double x=startingBound; x<=endingBound; x=x+dx) {\r\n \t\t//System.out.println(x+\", \"+f(x));\r\n \t\tcubes.add(new Cube(x*scaleX, -f(x)/scaleY, 0, f(x)/scaleY, dx*scaleX));\r\n \t\t//cubes.add(new Cube(x, 100, 0, 100, 100));\r\n \t}\r\n \t\r\n \t\r\n }","public CubeGL2(double width, double height, double depth) {\n // Define points for a cube.\n // X, Y, Z\n mCubeVertexData = new float[]\n {\n // Front face\n -1.0f, 1.0f, 1.0f,\n -1.0f, -1.0f, 1.0f,\n 1.0f, 1.0f, 1.0f,\n -1.0f, -1.0f, 1.0f,\n 1.0f, -1.0f, 1.0f,\n 1.0f, 1.0f, 1.0f,\n // Right face\n 1.0f, 1.0f, 1.0f,\n 1.0f, -1.0f, 1.0f,\n 1.0f, 1.0f, -1.0f,\n 1.0f, -1.0f, 1.0f,\n 1.0f, -1.0f, -1.0f,\n 1.0f, 1.0f, -1.0f,\n // Back face\n 1.0f, 1.0f, -1.0f,\n 1.0f, -1.0f, -1.0f,\n -1.0f, 1.0f, -1.0f,\n 1.0f, -1.0f, -1.0f,\n -1.0f, -1.0f, -1.0f,\n -1.0f, 1.0f, -1.0f,\n // Left face\n -1.0f, 1.0f, -1.0f,\n -1.0f, -1.0f, -1.0f,\n -1.0f, 1.0f, 1.0f,\n -1.0f, -1.0f, -1.0f,\n -1.0f, -1.0f, 1.0f,\n -1.0f, 1.0f, 1.0f,\n // Top face\n -1.0f, 1.0f, -1.0f,\n -1.0f, 1.0f, 1.0f,\n 1.0f, 1.0f, -1.0f,\n -1.0f, 1.0f, 1.0f,\n 1.0f, 1.0f, 1.0f,\n 1.0f, 1.0f, -1.0f,\n // Bottom face\n 1.0f, -1.0f, -1.0f,\n 1.0f, -1.0f, 1.0f,\n -1.0f, -1.0f, -1.0f,\n 1.0f, -1.0f, 1.0f,\n -1.0f, -1.0f, 1.0f,\n -1.0f, -1.0f, -1.0f,\n };\n\n for (int i = 0; i < mCubeVertexData.length; i += 3) {\n mCubeVertexData[i] = mCubeVertexData[i] * (float) width;\n }\n for (int i = 1; i < mCubeVertexData.length; i += 3) {\n mCubeVertexData[i] = mCubeVertexData[i] * (float) height;\n }\n for (int i = 2; i < mCubeVertexData.length; i += 3) {\n mCubeVertexData[i] = mCubeVertexData[i] * (float) depth;\n }\n\n // R, G, B, A\n mCubeColourData = new float[]\n {\n // Front face\n 1.0f, 0.0f, 0.0f, 1.0f,\n 1.0f, 0.0f, 0.0f, 1.0f,\n 1.0f, 0.0f, 0.0f, 1.0f,\n 1.0f, 0.0f, 0.0f, 1.0f,\n 1.0f, 0.0f, 0.0f, 1.0f,\n 1.0f, 0.0f, 0.0f, 1.0f,\n // Right face\n 0.0f, 1.0f, 0.0f, 1.0f,\n 0.0f, 1.0f, 0.0f, 1.0f,\n 0.0f, 1.0f, 0.0f, 1.0f,\n 0.0f, 1.0f, 0.0f, 1.0f,\n 0.0f, 1.0f, 0.0f, 1.0f,\n 0.0f, 1.0f, 0.0f, 1.0f,\n // Back face\n 0.0f, 0.0f, 1.0f, 1.0f,\n 0.0f, 0.0f, 1.0f, 1.0f,\n 0.0f, 0.0f, 1.0f, 1.0f,\n 0.0f, 0.0f, 1.0f, 1.0f,\n 0.0f, 0.0f, 1.0f, 1.0f,\n 0.0f, 0.0f, 1.0f, 1.0f,\n // Left face\n 1.0f, 1.0f, 0.0f, 1.0f,\n 1.0f, 1.0f, 0.0f, 1.0f,\n 1.0f, 1.0f, 0.0f, 1.0f,\n 1.0f, 1.0f, 0.0f, 1.0f,\n 1.0f, 1.0f, 0.0f, 1.0f,\n 1.0f, 1.0f, 0.0f, 1.0f,\n // Top face\n 0.0f, 1.0f, 1.0f, 1.0f,\n 0.0f, 1.0f, 1.0f, 1.0f,\n 0.0f, 1.0f, 1.0f, 1.0f,\n 0.0f, 1.0f, 1.0f, 1.0f,\n 0.0f, 1.0f, 1.0f, 1.0f,\n 0.0f, 1.0f, 1.0f, 1.0f,\n // Bottom face\n 1.0f, 0.0f, 1.0f, 1.0f,\n 1.0f, 0.0f, 1.0f, 1.0f,\n 1.0f, 0.0f, 1.0f, 1.0f,\n 1.0f, 0.0f, 1.0f, 1.0f,\n 1.0f, 0.0f, 1.0f, 1.0f,\n 1.0f, 0.0f, 1.0f, 1.0f\n };\n // X, Y, Z\n mCubeNormalData = new float[]\n {\n // Front face\n 0.0f, 0.0f, 1.0f,\n 0.0f, 0.0f, 1.0f,\n 0.0f, 0.0f, 1.0f,\n 0.0f, 0.0f, 1.0f,\n 0.0f, 0.0f, 1.0f,\n 0.0f, 0.0f, 1.0f,\n // Right face\n 1.0f, 0.0f, 0.0f,\n 1.0f, 0.0f, 0.0f,\n 1.0f, 0.0f, 0.0f,\n 1.0f, 0.0f, 0.0f,\n 1.0f, 0.0f, 0.0f,\n 1.0f, 0.0f, 0.0f,\n // Back face\n 0.0f, 0.0f, -1.0f,\n 0.0f, 0.0f, -1.0f,\n 0.0f, 0.0f, -1.0f,\n 0.0f, 0.0f, -1.0f,\n 0.0f, 0.0f, -1.0f,\n 0.0f, 0.0f, -1.0f,\n // Left face\n -1.0f, 0.0f, 0.0f,\n -1.0f, 0.0f, 0.0f,\n -1.0f, 0.0f, 0.0f,\n -1.0f, 0.0f, 0.0f,\n -1.0f, 0.0f, 0.0f,\n -1.0f, 0.0f, 0.0f,\n // Top face\n 0.0f, 1.0f, 0.0f,\n 0.0f, 1.0f, 0.0f,\n 0.0f, 1.0f, 0.0f,\n 0.0f, 1.0f, 0.0f,\n 0.0f, 1.0f, 0.0f,\n 0.0f, 1.0f, 0.0f,\n // Bottom face\n 0.0f, -1.0f, 0.0f,\n 0.0f, -1.0f, 0.0f,\n 0.0f, -1.0f, 0.0f,\n 0.0f, -1.0f, 0.0f,\n 0.0f, -1.0f, 0.0f,\n 0.0f, -1.0f, 0.0f\n };\n // X, Y\n // Texture coordinate data.\n mCubeTextureCoordinateData = new float[]\n {\n // Front face\n 0.0f, 0.0f,\n 0.0f, 1.0f,\n 1.0f, 0.0f,\n 0.0f, 1.0f,\n 1.0f, 1.0f,\n 1.0f, 0.0f,\n // Right face\n 0.0f, 0.0f,\n 0.0f, 1.0f,\n 1.0f, 0.0f,\n 0.0f, 1.0f,\n 1.0f, 1.0f,\n 1.0f, 0.0f,\n // Back face\n 0.0f, 0.0f,\n 0.0f, 1.0f,\n 1.0f, 0.0f,\n 0.0f, 1.0f,\n 1.0f, 1.0f,\n 1.0f, 0.0f,\n // Left face\n 0.0f, 0.0f,\n 0.0f, 1.0f,\n 1.0f, 0.0f,\n 0.0f, 1.0f,\n 1.0f, 1.0f,\n 1.0f, 0.0f,\n // Top face\n 0.0f, 0.0f,\n 0.0f, 1.0f,\n 1.0f, 0.0f,\n 0.0f, 1.0f,\n 1.0f, 1.0f,\n 1.0f, 0.0f,\n // Bottom face\n 0.0f, 0.0f,\n 0.0f, 1.0f,\n 1.0f, 0.0f,\n 0.0f, 1.0f,\n 1.0f, 1.0f,\n 1.0f, 0.0f\n };\n // Initialize the buffers.\n mCubeVertices = ByteBuffer.allocateDirect(mCubeVertexData.length * 4)\n .order(ByteOrder.nativeOrder()).asFloatBuffer();\n mCubeVertices.put(mCubeVertexData).position(0);\n mCubeColours = ByteBuffer.allocateDirect(mCubeColourData.length * 4)\n .order(ByteOrder.nativeOrder()).asFloatBuffer();\n mCubeColours.put(mCubeColourData).position(0);\n mCubeNormals = ByteBuffer.allocateDirect(mCubeNormalData.length * 4)\n .order(ByteOrder.nativeOrder()).asFloatBuffer();\n mCubeNormals.put(mCubeNormalData).position(0);\n mCubeTextureCoordinates = ByteBuffer.allocateDirect(mCubeTextureCoordinateData.length * 4)\n .order(ByteOrder.nativeOrder()).asFloatBuffer();\n mCubeTextureCoordinates.put(mCubeTextureCoordinateData).position(0);\n Matrix.setIdentityM(mModelMatrix, 0);\n }","public Polygon getPolygon(double eyeDistance){\n //define the front two verticies of the currentTrack\n Point3D track_vertex0 = currentTrack.getVertex(0);\n Point3D track_vertex1 = currentTrack.getVertex(1);\n //use center point to define the center of the sphape\n int cubeSize = 3;\n\n Point3D front_up_left = new Point3D (centerPoint.x-cubeSize, centerPoint.y-cubeSize, centerPoint.z-cubeSize);\n Point3D front_down_left = new Point3D (centerPoint.x-cubeSize, centerPoint.y+cubeSize, centerPoint.z-cubeSize);\n Point3D front_down_right = new Point3D (centerPoint.x+cubeSize, centerPoint.y+cubeSize, centerPoint.z-cubeSize);\n Point3D front_up_right = new Point3D (centerPoint.x+cubeSize, centerPoint.y-cubeSize, centerPoint.z-cubeSize);\n\n Point3D back_up_left = new Point3D (front_up_left.x, front_up_left.y, centerPoint.z+cubeSize);\n Point3D back_down_left = new Point3D (front_down_left.x, front_down_left.y, centerPoint.z+cubeSize);\n Point3D back_down_right = new Point3D (front_down_right.x, front_down_right.y, centerPoint.z+cubeSize);\n Point3D back_up_right = new Point3D (front_up_right.x, front_up_right.y, centerPoint.z+cubeSize);\n\n //aranges verticies in the order they will be drawn\n Point3D[] cube_verticies = {front_up_left, front_down_left, front_down_right, front_up_right,\n front_up_left, back_up_left, back_up_right, front_up_right,\n front_down_right, back_down_right, back_up_right, back_down_right,\n back_down_left, back_up_left, back_down_left, front_down_left};\n\n int[] x_points = new int[16];\n int[] y_points = new int[16];\n //convert 3D points to 2D points\n for(int i=0;i<16;i++){\n if(cube_verticies[i].z <= 200){ //same fix as for the track positioning\n x_points[i] = (int) -cube_verticies[i].projectPoint3D(eyeDistance).getX();\n y_points[i] = (int) cube_verticies[i].projectPoint3D(eyeDistance).getY();\n }\n else{\n x_points[i] = (int) cube_verticies[i].projectPoint3D(eyeDistance).getX();\n y_points[i] = (int) cube_verticies[i].projectPoint3D(eyeDistance).getY();\n }\n }\n Polygon polygon = new Polygon(x_points, y_points, 16);\n return polygon;\n }","public Cylinder(double height, double radius, boolean Center) {\n\t\tsuper();\n\t\tthis.height = height;\n\t\tthis.radius = radius;\n\t\tthis.center = Center;\n\t}","public void makeSphere (float radius, int slices, int stacks)\r\n {\r\n \t\r\n \tPoint lower[][] = new Point[stacks + 1][slices + 1];\r\n \tfloat rad[] = new float[stacks + 1];\r\n \tfloat vert = -0.5f;\r\n \t\r\n \t// Calculate radius for each stack\r\n \tfor(int i = 0; i <= stacks; i ++)\r\n \t{\r\n \t\trad[i] = (float)Math.sqrt((0.5f * 0.5f) - (( 0.5f - ( ( 1.0f/(float)stacks) * i ) ) * ( 0.5f - ( ( 1.0f/(float)stacks) * i ) ) ));\r\n\t\t}\r\n \t\r\n \tvert = -0.5f;\r\n \t\r\n \t// Calculate the vertices for each stack\r\n \tfor(int i = 0; i <= stacks; i ++ )\r\n \t{\r\n \t\tfor(int j = 0; j <= slices; j ++)\r\n \t\t{\r\n \t\t\tlower[i][j] = new Point();\r\n \t\t\tlower[i][j].x = rad[i] * (float)Math.cos(Math.toRadians ( (360.0f / (float)slices) * j ) );\r\n \t\t\tlower[i][j].z = rad[i] * (float)Math.sin(Math.toRadians ( (360.0f / (float)slices) * j ) );\r\n \t\t\tlower[i][j].y = vert;\r\n \t\t}\r\n \t\t// Update the y coordinate for the next stack\r\n \t\tvert += (1.0f / (float)stacks);\r\n \t}\r\n \t\r\n \t\r\n \t// Print all the triangles using the vertices\r\n \tfor(int i = 0 ; i < stacks; i++)\r\n \t\tfor(int j = 0 ; j < slices; j++)\r\n \t\t{\r\n \t\t\tthis.addTriangle(lower[i][j].x, lower[i][j].y, lower[i][j].z, lower[i][j+1].x, lower[i][j+1].y, lower[i][j+1].z, lower[i+1][j+1].x, lower[i+1][j+1].y, lower[i+1][j+1].z);\r\n \t\t\tthis.addTriangle(lower[i][j].x, lower[i][j].y, lower[i][j].z, lower[i+1][j+1].x, lower[i+1][j+1].y, lower[i+1][j+1].z, lower[i+1][j].x, lower[i+1][j].y, lower[i+1][j].z);\r\n \t\t}\r\n }","public void draw() {\n\t\tapplyColors();\n\n\t\tfloat halfHeight = height / 2,\n\t\t\t\tdiameter = 2 * radius;\n\n\t\tRobotRun.getInstance().translate(0f, 0f, halfHeight);\n\t\t// Draw top of the cylinder\n\t\tRobotRun.getInstance().ellipse(0f, 0f, diameter, diameter);\n\t\tRobotRun.getInstance().translate(0f, 0f, -height);\n\t\t// Draw bottom of the cylinder\n\t\tRobotRun.getInstance().ellipse(0f, 0f, diameter, diameter);\n\t\tRobotRun.getInstance().translate(0f, 0f, halfHeight);\n\n\t\tRobotRun.getInstance().beginShape(RobotRun.TRIANGLE_STRIP);\n\t\t// Draw a string of triangles around the circumference of the Cylinders top and bottom.\n\t\tfor (int degree = 0; degree <= 360; ++degree) {\n\t\t\tfloat pos_x = RobotRun.cos(RobotRun.DEG_TO_RAD * degree) * radius,\n\t\t\t\t\tpos_y = RobotRun.sin(RobotRun.DEG_TO_RAD * degree) * radius;\n\n\t\t\tRobotRun.getInstance().vertex(pos_x, pos_y, halfHeight);\n\t\t\tRobotRun.getInstance().vertex(pos_x, pos_y, -halfHeight);\n\t\t}\n\n\t\tRobotRun.getInstance().endShape();\n\t}","public DiscMesh(float radius, int numVertices) {\n Validate.nonNegative(radius, \"radius\");\n Validate.inRange(\n numVertices, \"number of vertices\", 3, Integer.MAX_VALUE);\n\n setMode(Mode.TriangleFan);\n\n float[] normals = new float[numAxes * numVertices];\n float[] positions = new float[numAxes * numVertices];\n float[] texCoords = new float[2 * numVertices];\n\n for (int vi = 0; vi < numVertices; ++vi) {\n normals[numAxes * vi] = 0f;\n normals[numAxes * vi + 1] = 0f;\n normals[numAxes * vi + 2] = 1f;\n\n float theta = FastMath.TWO_PI * vi / numVertices;\n float sin = FastMath.sin(theta);\n float cos = FastMath.cos(theta);\n positions[numAxes * vi] = radius * cos;\n positions[numAxes * vi + 1] = radius * sin;\n positions[numAxes * vi + 2] = 0f;\n\n texCoords[2 * vi] = (1f + cos) / 2f;\n texCoords[2 * vi + 1] = (1f + sin) / 2f;\n }\n\n setBuffer(Type.Normal, numAxes, normals);\n setBuffer(Type.Position, numAxes, positions);\n setBuffer(Type.TexCoord, 2, texCoords);\n\n updateBound();\n setStatic();\n }","public Cylinder() {\n\t\tthis(1.0);\n\t}","private void createTrackContour(ArrayList contour, double radius) {\r\n // Create vertices for the left half circle\r\n for (int alpha = 90; alpha <= 270; alpha++) {\r\n // A contours vertex (coordinates, color, texture)\r\n double vertex[] = new double[9];\r\n\r\n // Apply color\r\n vertex[3] = trackColor.getRed();\r\n vertex[4] = trackColor.getGreen();\r\n vertex[5] = trackColor.getBlue();\r\n vertex[6] = trackColor.getAlpha();\r\n\r\n // Apply texture coordinates (no texture)\r\n vertex[7] = vertex[8] = 0;\r\n\r\n // Calculate the coordinates of a point lying on the half circle\r\n double u, v;\r\n\r\n u = Math.cos(alpha * (Math.PI / 180)) * radius;\r\n v = Math.sin(alpha * (Math.PI / 180)) * radius;\r\n\r\n // Apply coordinates\r\n vertex[0] = x1 + u;\r\n vertex[1] = y1 + v;\r\n vertex[2] = 0;\r\n\r\n // Add the vertex to the contour list\r\n contour.add(vertex);\r\n }\r\n\r\n // Create vertices for the right half circle\r\n for (int alpha = 270; alpha <= 450; alpha++) {\r\n // A contours vertex (coordinates, color, texture)\r\n double vertex[] = new double[9];\r\n\r\n // Apply color\r\n vertex[3] = trackColor.getRed();\r\n vertex[4] = trackColor.getGreen();\r\n vertex[5] = trackColor.getBlue();\r\n vertex[6] = trackColor.getAlpha();\r\n\r\n // Apply texture coordinates (no texture)\r\n vertex[7] = vertex[8] = 0;\r\n\r\n // Calculate the coordinates of a point lying on the half circle\r\n double u, v;\r\n\r\n u = Math.cos(alpha * (Math.PI / 180)) * radius;\r\n v = Math.sin(alpha * (Math.PI / 180)) * radius;\r\n\r\n // Apply coordinates\r\n vertex[0] = x2 + u;\r\n vertex[1] = y2 + v;\r\n vertex[2] = 0;\r\n\r\n // Add the vertex to the contour list\r\n contour.add(vertex);\r\n }\r\n }","public Vector2f[] generatePatch(){\n\t\tVector2f[] vertices = new Vector2f[16];\n\t\t\n\t\tint index = 0;\n\t\t\n\t\tvertices[index++] = new Vector2f(0,0);\n\t\tvertices[index++] = new Vector2f(0.333f,0);\n\t\tvertices[index++] = new Vector2f(0.666f,0);\n\t\tvertices[index++] = new Vector2f(1,0);\n\t\t\n\t\tvertices[index++] = new Vector2f(0,0.333f);\n\t\tvertices[index++] = new Vector2f(0.333f,0.333f);\n\t\tvertices[index++] = new Vector2f(0.666f,0.333f);\n\t\tvertices[index++] = new Vector2f(1,0.333f);\n\t\t\n\t\tvertices[index++] = new Vector2f(0,0.666f);\n\t\tvertices[index++] = new Vector2f(0.333f,0.666f);\n\t\tvertices[index++] = new Vector2f(0.666f,0.666f);\n\t\tvertices[index++] = new Vector2f(1,0.666f);\n\t\n\t\tvertices[index++] = new Vector2f(0,1);\n\t\tvertices[index++] = new Vector2f(0.333f,1);\n\t\tvertices[index++] = new Vector2f(0.666f,1);\n\t\tvertices[index++] = new Vector2f(1,1);\n\t\t\n\t\treturn vertices;\n\t}","public static double cylinderVolume(double radius, double height){\n return Math.PI * square(radius) * height;\n }","public CylinderPanel() {\n\t\t\n\t\trInput = new JLabel(\"R = \");\n\t\trInput.setAlignmentX(JLabel.RIGHT_ALIGNMENT);\n\t rInput.setHorizontalAlignment(JLabel.RIGHT);\n\t\thInput = new JLabel(\"H = \");\n\t\thInput.setAlignmentX(JLabel.RIGHT_ALIGNMENT);\n\t hInput.setHorizontalAlignment(JLabel.RIGHT);\n\t\tvOutput = new JLabel(\"Volume: \");\n\t\tvOutput.setAlignmentX(JLabel.RIGHT_ALIGNMENT);\n\t vOutput.setHorizontalAlignment(JLabel.RIGHT);\n\t\tsaOutput = new JLabel(\"Surface Area: \");\n\t\tsaOutput.setAlignmentX(JLabel.RIGHT_ALIGNMENT);\n\t saOutput.setHorizontalAlignment(JLabel.RIGHT);\n\t\tvResult = new JLabel(\" --\");\n\t\tsaResult = new JLabel(\" --\");\n\t\t\n\t\trText = new JTextField(10);\n\t\thText = new JTextField(10);\n\t\t\n\t\tclear = new JButton(\"Clear\");\n\t\tcalculate = new JButton(\"Calculate\");\n\t\t\n\t\ts = new Cylinder();\n\t\t\n\t\tsetBorder(BorderFactory.createTitledBorder(\"Cylinder\"));\n\t\t\n\t\tadd(rInput);\n\t\tadd(rText);\n\t\tadd(hInput);\n\t\tadd(hText);\n\t\tadd(vOutput);\n\t\tadd(vResult);\n\t\tadd(saOutput);\n\t\tadd(saResult);\n\t\tadd(clear);\n\t\tadd(calculate);\n\t\t\n\t\tButtonListener listener = new ButtonListener();\n\t\t\n\t\tclear.addActionListener(listener);\n\t\tcalculate.addActionListener(listener);\n\t\t\n\t\t\n\t}","public static double volumeCylinder( double radius, double height ) {\n return Math.PI * areaCircle(radius) * height;\n }","public static double cylinderArea(double r, double h) {\r\n return 2 * Math.PI * r * h + 2 * Math.PI * r * r;\r\n }","public abstract void constructHull();","public static Cylinder buildRobotCylinder() {\n Cylinder robotCylinder = new Cylinder(\n ROBOT_CYLINDER_LENGTH,\n ROBOT_CYLINDER_RADIUS,\n CYLINDER_NUM_LENGTH_SEGMENTS,\n CYLINDER_NUM_CIRCLE_SEGMENTS\n );\n Material m = new Material(true);\n m.setColor(COLOR_BLUE_50_TRANSPARENT);\n robotCylinder.setMaterial(m);\n robotCylinder.setTransparent(true);\n robotCylinder.setDoubleSided(true);\n robotCylinder.rotate(Vector3.Axis.X, 90.0); // Vertical, like the Y-axis\n\n return robotCylinder;\n }","public float[] makeVertices(float radius, float[] color)\n {\n int noOfComponents = 3 + 3 + 3; // 3 position coordinates, 3 color coordinates, 3 normal coordinates\n float[] vertices = new float[(verticalResolution+1) * horizontalResolution * noOfComponents];\n int vertexNumberInc = 3 + 3 + 3; // three position coordinates, three color values, three normal coordinates\n int vertexNumber = 0;\n\n float elevation = 0;\n float elevationInc = (float) (Math.PI / verticalResolution);\n float azimuth = 0;\n float azimuthInc = (float) (2* Math.PI / horizontalResolution);\n for(int elevationIndex = 0; elevationIndex <= verticalResolution; elevationIndex++) {\n azimuth = 0;\n for(int azimuthIndex = 0; azimuthIndex < horizontalResolution; azimuthIndex++) {\n // position coordinates in spherical coordinates\n float xPos = radius * (float) (Math.sin(elevation) * Math.cos(azimuth));\n float yPos = radius * (float) (Math.sin(elevation) * Math.sin(azimuth));\n float zPos = radius * (float) Math.cos(elevation);\n vertices[vertexNumber] = xPos;\n vertices[vertexNumber+1] = yPos;\n vertices[vertexNumber+2] = zPos;\n // color coordinates (for all vertices the same)\n vertices[vertexNumber+3] = color[0];\n vertices[vertexNumber+4] = color[1];\n vertices[vertexNumber+5] = color[2];\n // coordinates of normal vector\n // for a sphere this vector is identical to the normalizes position vector\n float normalizationFactor = 1 / (float) Math.sqrt((xPos * xPos) + (yPos * yPos) + (zPos * zPos));\n vertices[vertexNumber+6] = xPos * normalizationFactor;\n vertices[vertexNumber+7] = yPos * normalizationFactor;\n vertices[vertexNumber+8] = zPos * normalizationFactor;\n\n vertexNumber += vertexNumberInc;\n azimuth += azimuthInc;\n }\n elevation += elevationInc;\n }\n return vertices;\n }","public CubeGL2() {\n // Define points for a cube.\n // X, Y, Z\n mCubeVertexData = new float[]\n {\n // Front face\n -1.0f, 1.0f, 1.0f,\n -1.0f, -1.0f, 1.0f,\n 1.0f, 1.0f, 1.0f,\n -1.0f, -1.0f, 1.0f,\n 1.0f, -1.0f, 1.0f,\n 1.0f, 1.0f, 1.0f,\n // Right face\n 1.0f, 1.0f, 1.0f,\n 1.0f, -1.0f, 1.0f,\n 1.0f, 1.0f, -1.0f,\n 1.0f, -1.0f, 1.0f,\n 1.0f, -1.0f, -1.0f,\n 1.0f, 1.0f, -1.0f,\n // Back face\n 1.0f, 1.0f, -1.0f,\n 1.0f, -1.0f, -1.0f,\n -1.0f, 1.0f, -1.0f,\n 1.0f, -1.0f, -1.0f,\n -1.0f, -1.0f, -1.0f,\n -1.0f, 1.0f, -1.0f,\n // Left face\n -1.0f, 1.0f, -1.0f,\n -1.0f, -1.0f, -1.0f,\n -1.0f, 1.0f, 1.0f,\n -1.0f, -1.0f, -1.0f,\n -1.0f, -1.0f, 1.0f,\n -1.0f, 1.0f, 1.0f,\n // Top face\n -1.0f, 1.0f, -1.0f,\n -1.0f, 1.0f, 1.0f,\n 1.0f, 1.0f, -1.0f,\n -1.0f, 1.0f, 1.0f,\n 1.0f, 1.0f, 1.0f,\n 1.0f, 1.0f, -1.0f,\n // Bottom face\n 1.0f, -1.0f, -1.0f,\n 1.0f, -1.0f, 1.0f,\n -1.0f, -1.0f, -1.0f,\n 1.0f, -1.0f, 1.0f,\n -1.0f, -1.0f, 1.0f,\n -1.0f, -1.0f, -1.0f,\n };\n // R, G, B, A\n mCubeColourData = new float[]\n {\n // Front face\n 1.0f, 0.0f, 0.0f, 1.0f,\n 1.0f, 0.0f, 0.0f, 1.0f,\n 1.0f, 0.0f, 0.0f, 1.0f,\n 1.0f, 0.0f, 0.0f, 1.0f,\n 1.0f, 0.0f, 0.0f, 1.0f,\n 1.0f, 0.0f, 0.0f, 1.0f,\n // Right face\n 0.0f, 1.0f, 0.0f, 1.0f,\n 0.0f, 1.0f, 0.0f, 1.0f,\n 0.0f, 1.0f, 0.0f, 1.0f,\n 0.0f, 1.0f, 0.0f, 1.0f,\n 0.0f, 1.0f, 0.0f, 1.0f,\n 0.0f, 1.0f, 0.0f, 1.0f,\n // Back face\n 0.0f, 0.0f, 1.0f, 1.0f,\n 0.0f, 0.0f, 1.0f, 1.0f,\n 0.0f, 0.0f, 1.0f, 1.0f,\n 0.0f, 0.0f, 1.0f, 1.0f,\n 0.0f, 0.0f, 1.0f, 1.0f,\n 0.0f, 0.0f, 1.0f, 1.0f,\n // Left face\n 1.0f, 1.0f, 0.0f, 1.0f,\n 1.0f, 1.0f, 0.0f, 1.0f,\n 1.0f, 1.0f, 0.0f, 1.0f,\n 1.0f, 1.0f, 0.0f, 1.0f,\n 1.0f, 1.0f, 0.0f, 1.0f,\n 1.0f, 1.0f, 0.0f, 1.0f,\n // Top face\n 0.0f, 1.0f, 1.0f, 1.0f,\n 0.0f, 1.0f, 1.0f, 1.0f,\n 0.0f, 1.0f, 1.0f, 1.0f,\n 0.0f, 1.0f, 1.0f, 1.0f,\n 0.0f, 1.0f, 1.0f, 1.0f,\n 0.0f, 1.0f, 1.0f, 1.0f,\n // Bottom face\n 1.0f, 0.0f, 1.0f, 1.0f,\n 1.0f, 0.0f, 1.0f, 1.0f,\n 1.0f, 0.0f, 1.0f, 1.0f,\n 1.0f, 0.0f, 1.0f, 1.0f,\n 1.0f, 0.0f, 1.0f, 1.0f,\n 1.0f, 0.0f, 1.0f, 1.0f\n };\n // X, Y, Z\n mCubeNormalData = new float[]\n {\n // Front face\n 0.0f, 0.0f, 1.0f,\n 0.0f, 0.0f, 1.0f,\n 0.0f, 0.0f, 1.0f,\n 0.0f, 0.0f, 1.0f,\n 0.0f, 0.0f, 1.0f,\n 0.0f, 0.0f, 1.0f,\n // Right face\n 1.0f, 0.0f, 0.0f,\n 1.0f, 0.0f, 0.0f,\n 1.0f, 0.0f, 0.0f,\n 1.0f, 0.0f, 0.0f,\n 1.0f, 0.0f, 0.0f,\n 1.0f, 0.0f, 0.0f,\n // Back face\n 0.0f, 0.0f, -1.0f,\n 0.0f, 0.0f, -1.0f,\n 0.0f, 0.0f, -1.0f,\n 0.0f, 0.0f, -1.0f,\n 0.0f, 0.0f, -1.0f,\n 0.0f, 0.0f, -1.0f,\n // Left face\n -1.0f, 0.0f, 0.0f,\n -1.0f, 0.0f, 0.0f,\n -1.0f, 0.0f, 0.0f,\n -1.0f, 0.0f, 0.0f,\n -1.0f, 0.0f, 0.0f,\n -1.0f, 0.0f, 0.0f,\n // Top face\n 0.0f, 1.0f, 0.0f,\n 0.0f, 1.0f, 0.0f,\n 0.0f, 1.0f, 0.0f,\n 0.0f, 1.0f, 0.0f,\n 0.0f, 1.0f, 0.0f,\n 0.0f, 1.0f, 0.0f,\n // Bottom face\n 0.0f, -1.0f, 0.0f,\n 0.0f, -1.0f, 0.0f,\n 0.0f, -1.0f, 0.0f,\n 0.0f, -1.0f, 0.0f,\n 0.0f, -1.0f, 0.0f,\n 0.0f, -1.0f, 0.0f\n };\n // X, Y\n // Texture coordinate data.\n mCubeTextureCoordinateData = new float[]\n {\n // Front face\n 0.0f, 0.0f,\n 0.0f, 1.0f,\n 1.0f, 0.0f,\n 0.0f, 1.0f,\n 1.0f, 1.0f,\n 1.0f, 0.0f,\n // Right face\n 0.0f, 0.0f,\n 0.0f, 1.0f,\n 1.0f, 0.0f,\n 0.0f, 1.0f,\n 1.0f, 1.0f,\n 1.0f, 0.0f,\n // Back face\n 0.0f, 0.0f,\n 0.0f, 1.0f,\n 1.0f, 0.0f,\n 0.0f, 1.0f,\n 1.0f, 1.0f,\n 1.0f, 0.0f,\n // Left face\n 0.0f, 0.0f,\n 0.0f, 1.0f,\n 1.0f, 0.0f,\n 0.0f, 1.0f,\n 1.0f, 1.0f,\n 1.0f, 0.0f,\n // Top face\n 0.0f, 0.0f,\n 0.0f, 1.0f,\n 1.0f, 0.0f,\n 0.0f, 1.0f,\n 1.0f, 1.0f,\n 1.0f, 0.0f,\n // Bottom face\n 0.0f, 0.0f,\n 0.0f, 1.0f,\n 1.0f, 0.0f,\n 0.0f, 1.0f,\n 1.0f, 1.0f,\n 1.0f, 0.0f\n };\n // Initialize the buffers.\n mCubeVertices = ByteBuffer.allocateDirect(mCubeVertexData.length * 4)\n .order(ByteOrder.nativeOrder()).asFloatBuffer();\n mCubeVertices.put(mCubeVertexData).position(0);\n mCubeColours = ByteBuffer.allocateDirect(mCubeColourData.length * 4)\n .order(ByteOrder.nativeOrder()).asFloatBuffer();\n mCubeColours.put(mCubeColourData).position(0);\n mCubeNormals = ByteBuffer.allocateDirect(mCubeNormalData.length * 4)\n .order(ByteOrder.nativeOrder()).asFloatBuffer();\n mCubeNormals.put(mCubeNormalData).position(0);\n mCubeTextureCoordinates = ByteBuffer.allocateDirect(mCubeTextureCoordinateData.length * 4)\n .order(ByteOrder.nativeOrder()).asFloatBuffer();\n mCubeTextureCoordinates.put(mCubeTextureCoordinateData).position(0);\n Matrix.setIdentityM(mModelMatrix, 0);\n }","public SoCubeWithoutTop()\n//\n////////////////////////////////////////////////////////////////////////\n{\n nodeHeader.SO_NODE_CONSTRUCTOR();\n\n nodeHeader.SO_NODE_ADD_SFIELD(width,\"width\", (2.0f));\n nodeHeader.SO_NODE_ADD_SFIELD(height,\"height\", (2.0f));\n nodeHeader.SO_NODE_ADD_SFIELD(depth,\"depth\", (2.0f));\n\n isBuiltIn = true;\n\n if (nodeHeader.SO_NODE_IS_FIRST_INSTANCE()) {\n // Initialize corner coordinate values\n coords[0].setValue(-1.0f, 1.0f, -1.0f); // Left Top Back\n coords[1].setValue( 1.0f, 1.0f, -1.0f); // Right Top Back\n coords[2].setValue(-1.0f, -1.0f, -1.0f); // Left Bottom Back\n coords[3].setValue( 1.0f, -1.0f, -1.0f); // Right Bottom Back\n coords[4].setValue(-1.0f, 1.0f, 1.0f); // Left Top Front\n coords[5].setValue( 1.0f, 1.0f, 1.0f); // Right Top Front\n coords[6].setValue(-1.0f, -1.0f, 1.0f); // Left Bottom Front\n coords[7].setValue( 1.0f, -1.0f, 1.0f); // Right Bottom Front\n\n // Initialize face vertices to point into coords. The order of\n // vertices around the faces is chosen so that the texture\n // coordinates match up: texture coord (0,0) is at the first\n // vertex and (1,1) is at the third. The vertices obey the\n // right-hand rule for each face.\n verts[1][2] = verts[2][3] = verts[4][3] = coords[0];\n verts[1][3] = verts[3][2] = verts[4][2] = coords[1];\n verts[1][1] = verts[2][0] = verts[5][0] = coords[2];\n verts[1][0] = verts[3][1] = verts[5][1] = coords[3];\n verts[0][3] = verts[2][2] = verts[4][0] = coords[4];\n verts[0][2] = verts[3][3] = verts[4][1] = coords[5];\n verts[0][0] = verts[2][1] = verts[5][3] = coords[6];\n verts[0][1] = verts[3][0] = verts[5][2] = coords[7];\n\n // Initialize texture coordinates. These are for the 4 corners of\n // each face, starting at the lower left corner\n texCoords[0].setValue(0.0f, 0.0f);\n texCoords[1].setValue(1.0f, 0.0f);\n texCoords[2].setValue(1.0f, 1.0f);\n texCoords[3].setValue(0.0f, 1.0f);\n\n // Initialize face normals\n normals[0].setValue( 0.0f, 0.0f, 1.0f); // Front\n normals[1].setValue( 0.0f, 0.0f, -1.0f); // Back\n normals[2].setValue(-1.0f, 0.0f, 0.0f); // Left\n normals[3].setValue( 1.0f, 0.0f, 0.0f); // Right\n normals[4].setValue( 0.0f, 1.0f, 0.0f); // Top\n normals[5].setValue( 0.0f, -1.0f, 0.0f); // Bottom\n\n }\n}","void drawSphere(GL2 gl,GLU glu, double r, int lats, int longs) {\n\n\n\n GLUquadric qobj = glu.gluNewQuadric();\n\n gl.glColor4f(0.0f, 0.0f, 1.0f,0.01f);\n glu.gluQuadricDrawStyle(qobj, GLU.GLU_LINE);\n glu.gluQuadricNormals(qobj, GLU.GLU_SMOOTH);\n\n glu.gluSphere(qobj, r, 70, 70);\n\n /*\n int i, j;\n for(i = 0; i <= lats; i++) {\n float lat0 = (float) (Math.PI * (-0.5 + (double) (i - 1) / lats));\n float z0 = (float) (Math.sin(lat0));\n float zr0 = (float) (Math.cos(lat0));\n\n float lat1 = (float) (Math.PI * (-0.5 + (double) i / lats));\n float z1 = (float) (Math.sin(lat1));\n float zr1 = (float) (Math.expm1(lat1));\n\n gl.glBegin(GL_LINE_STRIP);\n gl.glColor3f(0.0f, 1.0f, 1.0f);\n for(j = 0; j <= longs; j++) {\n float lng = (float) (2. * Math.PI * (double) (j - 1) / longs);\n float x = (float) (r*Math.cos(lng));\n float y = (float) (r*Math.sin(lng));\n\n\n\n gl.glNormal3f(x * z0, y * z0,(float)r* zr0);\n gl.glVertex3f(x * z0, y * z0, (float) r*zr0);\n //gl.glNormal3f(x * zr1, y * zr1, (float) r*z1);\n //gl.glVertex3f(x * zr1, y * zr1, (float)r*z1);\n }\n gl.glEnd();\n }\n */\n }","public double getCylinderBaseArea();","@Override\r\n\tprotected void initShape() {\n\t\tgetPositions().putAll(createSymmetricLines(0, 1.5, .5, 1.1, WingPart.OUTER_LEFT, WingPart.OUTER_RIGHT));\r\n\t\t//->upper corner\r\n\t\tgetPositions().putAll(createSymmetricLines(.5, 1.1, 1, .7, WingPart.OUTER_LEFT, WingPart.OUTER_RIGHT));\r\n\t\t//-> lower outer corner\r\n\t\tgetPositions().putAll(createSymmetricLines(1, .7, 1.1, .3, WingPart.OUTER_LEFT, WingPart.OUTER_RIGHT));\r\n\t\t//-> lower inner corner\r\n\t\tgetPositions().putAll(createSymmetricLines(1.1, .3, .7, .25, WingPart.OUTER_LEFT, WingPart.OUTER_RIGHT));\r\n\t\t//-> middle\r\n\t\tgetPositions().putAll(createSymmetricLines(.7, .25, .2, 1.35, WingPart.OUTER_LEFT, WingPart.OUTER_RIGHT));\r\n\t\t//inner\r\n\t\tgetPositions().putAll(createSymmetricLines(1, .5, .55, 0.95, WingPart.INNER_LEFT, WingPart.INNER_RIGHT));\r\n\t\tgetPositions().putAll(createSymmetricLines(0.8, .4, .55, 0.95, WingPart.INNER_LEFT, WingPart.INNER_RIGHT));\r\n\t\tgetPositions().putAll(createSymmetricPoints(0.9, .5, WingPart.INNER_LEFT, WingPart.INNER_RIGHT));\r\n\r\n//\t\tgetPositions().putAll(fill(WingPart.OUTER_RIGHT, WingPart.INNER_RIGHT));\r\n//\t\tgetPositions().putAll(fill(WingPart.OUTER_LEFT, WingPart.INNER_LEFT));\r\n\t}","public static String buildCylinder(String controlPoints, String id, \n String name, String description, String lineColor, String fillColor, KmlOptions.AltitudeMode altitudeMode, \n SymbolModifiers attributes) {\n StringBuilder output = new StringBuilder(); \n String pointArrayStringList = \"\";\n\n // variables for the cylinder position\n double pivotx = 0.0D;\n double pivoty = 0.0D;\n\n try { \n \n // Get the points of the icons. For the cylinder we need only\n // one point. Ignore any more than the first point.\n String[] latlons = controlPoints.split(\" \");\n\n if (latlons.length > 0) {\n String[] pivot = latlons[0].split(\",\");\n\n if (pivot.length >= 2) {\n pivotx = Double.parseDouble(pivot[0]);\n pivoty = Double.parseDouble(pivot[1]);\n } else {\n throw new NumberFormatException();\n }\n } else {\n // throw an illegal number of points exception\n throw new InvalidNumberOfPointsException();\n }\n \n // Build the cylinder\n pointArrayStringList = XsltCoordinateWrapper.getCircleKml(pivotx,\n pivoty, id, name, description, lineColor, fillColor, altitudeMode,\n attributes.AM_DISTANCE.get(0),\n attributes.X_ALTITUDE_DEPTH.get(0),\n attributes.X_ALTITUDE_DEPTH.get(1)); \n } catch (Exception e) {\n pointArrayStringList = \"\"; \n }\n\n return pointArrayStringList;\n\n }","@Override\n public void paintComponent(Graphics g) {\n super.paintComponent(g);\n\n if (bdhcHandler != null) {\n int[] slopes = bdhcHandler.getSelectedPlate().getSlope();\n float angle = (float) Math.atan2(slopes[indexSlope1], slopes[indexSlope2]);\n\n Graphics2D g2 = (Graphics2D) g;\n g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING,\n RenderingHints.VALUE_ANTIALIAS_ON);\n\n g.setColor(Color.magenta);\n final int angleRadius = (radius * 2) / 3;\n final int angleOffset = size / 2 - angleRadius;\n g2.setStroke(new BasicStroke(2));\n g.drawArc(angleOffset, angleOffset, 2 * angleRadius, 2 * angleRadius, 0, (int) (-(angle * 180) / Math.PI));\n\n g2.setStroke(new BasicStroke(2));\n if (frontView) {\n g.setColor(Color.red);\n g.drawLine(size / 2, size / 2, size, size / 2);\n g.setColor(Color.blue);\n g.drawLine(size / 2, size / 2, size / 2, 0);\n } else {\n g.setColor(Color.green);\n //g.drawLine(size / 2, size / 2, size, size / 2);\n g.drawLine(size / 2, size / 2, size, size / 2);\n g.setColor(Color.blue);\n g.drawLine(size / 2, size / 2, size / 2, 0);\n }\n\n int circleOffset = size / 2 - radius;\n g.setColor(Color.black);\n g2.setStroke(new BasicStroke(1));\n g.drawOval(circleOffset, circleOffset, radius * 2, radius * 2);\n\n int x = (int) (Math.cos(angle) * radius);\n int y = (int) (Math.sin(angle) * radius);\n int lineOffset = size / 2;\n g.setColor(Color.orange);\n g2.setStroke(new BasicStroke(3));\n g.drawLine(lineOffset - x, lineOffset - y, lineOffset + x, lineOffset + y);\n\n }\n\n }","private List createSkeletonOfDegree (int degree1, int degree2) {\n List skeleton = new ArrayList();\n \n if (degree1 < 0 || degree2 < 0) { return skeleton; }\n int totalDegree = degree1 + degree2;\n for (int i = 0; i <= totalDegree; ++i) {\n skeleton.add(0.0);\n }\n return skeleton;\n }","public static double volumeOfCylinder(double r, double h) {\n double v = Math.PI * Math.pow(r, 2) * h;\n v = (double) Math.round(v * 100) / 100;\n return v;\n }","public void drawPolygon (int xC, int yC, int xP, int yP,int ribs, Graphics g){\r\n \r\n \tint n = ribs; \r\n \t//delta keep the the original delta , this size of delta will increase in delta size each time.\r\n \tdouble delta = (2* Math.PI)/ n;\r\n \tdouble deltaTemp = delta;\r\n \t//List of Points that I keep during n rotation.\r\n \tList points; \r\n \tfloat x,y,newX,newY;\r\n \t//First Sliding\r\n \tx = xP - xC;\r\n \ty = yP - yC;\r\n \tnewX = x; \t\r\n \tnewY = y; \t\r\n \tList vertexs = new ArrayList();\r\n \t//Follow delta angle rotation n times and write a list of vertices to vertexs list.\r\n \tfor (int i = 0; i < n ; i++)\r\n \t{\r\n \t\tnewX = (int) ((x*Math.cos(delta) - y*Math.sin(delta)));\r\n \t\tnewY = (int) ((x*Math.sin(delta) + y*Math.cos(delta))); \r\n \t\tvertexs.add(new Point(Math.round(newX),Math.round(newY))); \t\r\n \t\tSystem.out.println(vertexs.get(i).x+\",\"+vertexs.get(i).y);\r\n \t\tdelta = delta + deltaTemp;\r\n \t}\r\n \t//Sliding back\r\n \tfor (int i = 0; i < vertexs.size(); i++ ){\r\n \t\tvertexs.get(i).x = (int) (vertexs.get(i).getX() + xC);\r\n \t\tvertexs.get(i).y = (int) (vertexs.get(i).getY() + yC);\r\n \t\tg.drawRect(vertexs.get(i).x, vertexs.get(i).y ,1,1);\r\n \t}\r\n \t//draw line between the list of the points we got.\r\n \tfor (int z = 0 ; z < vertexs.size(); z++){\r\n \t\tif (z == vertexs.size()-1)\r\n \t\t\tdrawLine((int) Math.round(vertexs.get(z).getX()), (int)(vertexs.get(z).getY()),(int)(vertexs.get(0).getX()), (int)(vertexs.get(0).getY()),g);\r\n \t\telse\r\n \t\t\tdrawLine((int)(vertexs.get(z).getX()), (int)(vertexs.get(z).getY()),(int)(vertexs.get(z+1).getX()), (int)(vertexs.get(z+1).getY()),g);\r\n\r\n \t\t}\r\n \t\r\n }","Cube(int l, int b, int h)\r\n\t{\r\n\t\t//System.out.println(\"We are in constructor\");\r\n\t\tlength=l;\r\n\t\tbredth=b;\r\n\t\theight=h;\r\n\t}","public static void main(String[] args) throws FileNotFoundException\n {\n File file = new File(System.getProperty(\"user.home\") + \"/Desktop\", \"lion.off\");\n Scanner s = new Scanner(file);\n s.nextLine(); // Skip first line of context\n\n // Create result file(mesh2C.off)\n try { fileManager.CreateResultFile(); }\n catch(IOException exc) { System.out.println(\"Error: \" + exc.getMessage()); }\n \n // Initializing PrintWriter instance for writing data to result file\n PrintWriter pw = new PrintWriter(System.getProperty(\"user.home\") + \"/Desktop/mesh2C.off\");\n pw.println(\"OFF\"); // Write first line to mesh2C.off\n\n // Get number of vertices which lion.off has\n String str_num_of_vertices = s.next();\n String str_num_of_faces = s.next();\n int num_of_vertices = Integer.parseInt(str_num_of_vertices);\n int num_of_faces = Integer.parseInt(str_num_of_faces);\n pw.println(Integer.toString(num_of_vertices + 8) + \" \" + Integer.toString(num_of_faces + 6) + s.nextLine());\n\n // Extract max and min value of each axis(X, Y, Z) separately\n double minX = 0, maxX = 0;\n double minY = 0, maxY = 0;\n double minZ = 0, maxZ = 0;\n\n for(int i = 0; i < num_of_vertices; i++)\n {\n double x = Double.parseDouble(s.next());\n if(x < minX) { minX = x; }\n if(x > maxX) { maxX = x; }\n double y = Double.parseDouble(s.next());\n if(y < minY) { minY = y; }\n if(y > maxY) { maxY = y; }\n double z = Double.parseDouble(s.next());\n if(z < minZ) { minZ = z; }\n if(z > maxZ) { maxZ = z; }\n\n String tmp = Double.toString(x) + \" \" + Double.toString(y) + \" \" + Double.toString(z);\n pw.println(tmp); \n }\n\n // Calculate and create String arrays for Vertices and faces\n String vStr[] = new String[8];\n String fStr[] = new String[6];\n\n vStr[0] = Double.toString(minX) + \" \" + Double.toString(maxY) + \" \" + Double.toString(maxZ);\n vStr[1] = Double.toString(minX) + \" \" + Double.toString(minY) + \" \" + Double.toString(maxZ);\n vStr[2] = Double.toString(maxX) + \" \" + Double.toString(minY) + \" \" + Double.toString(maxZ);\n vStr[3] = Double.toString(maxX) + \" \" + Double.toString(maxY) + \" \" + Double.toString(maxZ);\n vStr[4] = Double.toString(minX) + \" \" + Double.toString(maxY) + \" \" + Double.toString(minZ);\n vStr[5] = Double.toString(minX) + \" \" + Double.toString(minY) + \" \" + Double.toString(minZ);\n vStr[6] = Double.toString(maxX) + \" \" + Double.toString(minY) + \" \" + Double.toString(minZ);\n vStr[7] = Double.toString(maxX) + \" \" + Double.toString(maxY) + \" \" + Double.toString(minZ);\n\n for(int i = 0; i < 8; i++) { pw.println(vStr[i]); }\n \n // Calculate face list and write into result file\n String id_quad_1 = Integer.toString(num_of_vertices);\n String id_quad_2 = Integer.toString(num_of_vertices + 1);\n String id_quad_3 = Integer.toString(num_of_vertices + 2);\n String id_quad_4 = Integer.toString(num_of_vertices + 3);\n String id_quad_5 = Integer.toString(num_of_vertices + 4);\n String id_quad_6 = Integer.toString(num_of_vertices + 5);\n String id_quad_7 = Integer.toString(num_of_vertices + 6);\n String id_quad_8 = Integer.toString(num_of_vertices + 7);\n\n fStr[0] = \"4 \" + id_quad_1 + \" \" + id_quad_4 + \" \" + id_quad_3 + \" \" + id_quad_2;\n fStr[1] = \"4 \" + id_quad_5 + \" \" + id_quad_6 + \" \" + id_quad_7 + \" \" + id_quad_8;\n fStr[2] = \"4 \" + id_quad_1 + \" \" + id_quad_5 + \" \" + id_quad_8 + \" \" + id_quad_4;\n fStr[3] = \"4 \" + id_quad_3 + \" \" + id_quad_7 + \" \" + id_quad_6 + \" \" + id_quad_2;\n fStr[4] = \"4 \" + id_quad_2 + \" \" + id_quad_6 + \" \" + id_quad_5 + \" \" + id_quad_1;\n fStr[5] = \"4 \" + id_quad_4 + \" \" + id_quad_8 + \" \" + id_quad_7 + \" \" + id_quad_3;\n\n // Copy face data from original lion.off file to result file\n s.nextLine();\n for(int i = 0; i < num_of_faces; i++) { pw.println(s.nextLine()); }\n \n // Add new face data at the bottom of result file\n for(int i = 0; i < 6; i++) { pw.println(fStr[i]); }\n\n // Terminate filestream\n s.close();\n pw.close();\n }","@SuppressWarnings(\"unused\")\r\n private void makeSubcutaneousFat2DVOI() {\r\n\r\n // find the center of mass of the single label object in the sliceBuffer (abdomenImage)\r\n findAbdomenCM();\r\n int xcm = centerOfMass[0];\r\n int ycm = centerOfMass[1];\r\n \r\n VOIVector vois = abdomenImage.getVOIs();\r\n VOI theVOI = vois.get(0);\r\n\r\n // there should be only one VOI and one curve\r\n VOIContour curve = ((VOIContour)theVOI.getCurves().get(0));\r\n int[] xVals = new int [curve.size()];\r\n int[] yVals = new int [curve.size()];\r\n int[] zVals = new int [curve.size()];\r\n curve.exportArrays(xVals, yVals, zVals);\r\n \r\n int[] xValsSubcutaneousVOI = new int [curve.size()];\r\n int[] yValsSubcutaneousVOI = new int [curve.size()];\r\n \r\n \r\n // the intensity profile along a radial line for a given angle\r\n short[] profile;\r\n \r\n // the x, y location of all the pixels along a radial line for a given angle\r\n int[] xLocs;\r\n int[] yLocs;\r\n try {\r\n profile = new short[xDim];\r\n xLocs = new int[xDim];\r\n yLocs = new int[xDim];\r\n } catch (OutOfMemoryError error) {\r\n System.gc();\r\n MipavUtil.displayError(\"findAbdomenVOI(): Can NOT allocate profile\");\r\n return;\r\n }\r\n\r\n try {\r\n srcImage.exportData(0, sliceSize, sliceBuffer);\r\n } catch (IOException ex) {\r\n System.err.println(\"JCATsegmentAbdomen2D(): Error exporting data\");\r\n return;\r\n }\r\n\r\n\r\n // find a subcutaneous fat contour point for each abdominal contour point\r\n // we know the abdominal contour points are located at three degree increments\r\n double angleRad;\r\n int count;\r\n int contourPointIdx = 0;\r\n for (int angle = 0; angle < 360; angle += angularResolution) {\r\n count = 0;\r\n int x = xcm;\r\n int y = ycm;\r\n int yOffset = y * xDim;\r\n double scaleFactor; // reduces the number of trig operations that must be performed\r\n \r\n angleRad = Math.PI * angle / 180.0;\r\n if (angle > 315 || angle <= 45) {\r\n // increment x each step\r\n scaleFactor = Math.tan(angleRad);\r\n while (x < xVals[contourPointIdx]) {\r\n // store the intensity and location of each point along the radial line\r\n profile[count] = sliceBuffer[yOffset + x];\r\n xLocs[count] = x;\r\n yLocs[count] = y;\r\n count++;\r\n \r\n // walk out in x and compute the value of y for the given radial line\r\n x++;\r\n y = ycm - (int)((x - xcm) * scaleFactor);\r\n yOffset = y * xDim;\r\n }\r\n\r\n // profile contains all the source image intensity values along the line from\r\n // the center-of-mass to the abdomen VOI point\r\n // Find where the subcutaneous fat ends and the muscle starts\r\n \r\n // start at the end of the profile array since its order is from the\r\n // center-of-mass to the abdomen voi point\r\n \r\n int idx = count - 5; // skip over the skin\r\n while (idx >= 0 && profile[idx] < muscleThresholdHU && profile[idx] > airThresholdHU) {\r\n idx--;\r\n }\r\n if (idx <= 0) {\r\n MipavUtil.displayError(\"findAbdomenVOI(): Can NOT find visceral cavity in the intensity profile\");\r\n break;\r\n }\r\n xValsSubcutaneousVOI[contourPointIdx] = xLocs[idx];\r\n yValsSubcutaneousVOI[contourPointIdx] = yLocs[idx];\r\n \r\n } else if (angle > 45 && angle <= 135) {\r\n // decrement y each step\r\n scaleFactor = (Math.tan((Math.PI / 2.0) - angleRad));\r\n while (y > yVals[contourPointIdx]) {\r\n // store the intensity and location of each point along the radial line\r\n profile[count] = sliceBuffer[yOffset + x];\r\n xLocs[count] = x;\r\n yLocs[count] = y;\r\n count++;\r\n \r\n // walk to the top of the image and compute values of x for the given radial line\r\n y--;\r\n x = xcm + (int)((ycm - y) * scaleFactor);\r\n yOffset = y * xDim;\r\n }\r\n \r\n // profile contains all the source image intensity values along the line from\r\n // the center-of-mass to the newly computed abdomen VOI point\r\n // Find where the subcutaneous fat ends\r\n int idx = count - 5; // skip over the skin\r\n while (idx >= 0 && profile[idx] < muscleThresholdHU&& profile[idx] > airThresholdHU) {\r\n idx--;\r\n }\r\n if (idx == 0) {\r\n MipavUtil.displayError(\"findAbdomenVOI(): Can NOT find visceral cavity in the intensity profile\");\r\n return;\r\n }\r\n xValsSubcutaneousVOI[contourPointIdx] = xLocs[idx];\r\n yValsSubcutaneousVOI[contourPointIdx] = yLocs[idx];\r\n \r\n } else if (angle > 135 && angle <= 225) {\r\n // decrement x each step\r\n scaleFactor = Math.tan(Math.PI - angleRad);\r\n while (x > xVals[contourPointIdx]) {\r\n // store the intensity and location of each point along the radial line\r\n profile[count] = sliceBuffer[yOffset + x];\r\n xLocs[count] = x;\r\n yLocs[count] = y;\r\n count++;\r\n \r\n x--;\r\n y = ycm - (int)((xcm - x) * scaleFactor);\r\n yOffset = y * xDim;\r\n }\r\n \r\n // profile contains all the source image intensity values along the line from\r\n // the center-of-mass to the newly computed abdomen VOI point\r\n // Find where the subcutaneous fat ends\r\n int idx = count - 5; // skip over the skin\r\n while (idx >= 0 && profile[idx] < muscleThresholdHU&& profile[idx] > airThresholdHU) {\r\n idx--;\r\n }\r\n if (idx == 0) {\r\n MipavUtil.displayError(\"findAbdomenVOI(): Can NOT find visceral cavity in the intensity profile\");\r\n return;\r\n }\r\n xValsSubcutaneousVOI[contourPointIdx] = xLocs[idx];\r\n yValsSubcutaneousVOI[contourPointIdx] = yLocs[idx];\r\n \r\n } else if (angle > 225 && angle <= 315) {\r\n // increment y each step\r\n scaleFactor = Math.tan((3.0 * Math.PI / 2.0) - angleRad);\r\n while (y < yVals[contourPointIdx]) {\r\n // store the intensity and location of each point along the radial line\r\n profile[count] = sliceBuffer[yOffset + x];\r\n xLocs[count] = x;\r\n yLocs[count] = y;\r\n count++;\r\n \r\n y++;\r\n x = xcm - (int)((y - ycm) * scaleFactor);\r\n yOffset = y * xDim;\r\n }\r\n \r\n // profile contains all the source image intensity values along the line from\r\n // the center-of-mass to the newly computed abdomen VOI point\r\n // Find where the subcutaneous fat ends\r\n int idx = count - 5; // skip over the skin\r\n while (idx >= 0 && profile[idx] < muscleThresholdHU&& profile[idx] > airThresholdHU) {\r\n idx--;\r\n }\r\n if (idx == 0) {\r\n MipavUtil.displayError(\"findAbdomenVOI(): Can NOT find visceral cavity in the intensity profile\");\r\n return;\r\n }\r\n xValsSubcutaneousVOI[contourPointIdx] = xLocs[idx];\r\n yValsSubcutaneousVOI[contourPointIdx] = yLocs[idx];\r\n\r\n }\r\n \r\n contourPointIdx++;\r\n } // end for (angle = 0; ...\r\n\r\n\r\n // make the VOI's and add the points to them\r\n subcutaneousVOI = new VOI((short)0, \"Subcutaneous area\");\r\n subcutaneousVOI.importCurve(xValsSubcutaneousVOI, yValsSubcutaneousVOI, zVals);\r\n\r\n }","ArrayList> generateInitVertices() {\n ArrayList> vertices = new ArrayList>();\n for (int x = 0; x < width; x++) {\n ArrayList temp = new ArrayList();\n for (int y = 0; y < height; y++) {\n temp.add(new Vertex(x, y));\n }\n vertices.add(temp);\n }\n Random r = new Random();\n for (ArrayList vList : vertices) {\n for (Vertex v : vList) {\n if (v.x != 0) {\n v.outEdges.add(new Edge(v, vertices.get(v.x - 1).get(v.y), r.nextInt(1000)));\n }\n if (v.x != width - 1) {\n v.outEdges.add(new Edge(v, vertices.get(v.x + 1).get(v.y), r.nextInt(1000)));\n }\n if (v.y != 0) {\n v.outEdges.add(new Edge(v, vertices.get(v.x).get(v.y - 1), r.nextInt(1000)));\n }\n if (v.y != height - 1) {\n v.outEdges.add(new Edge(v, vertices.get(v.x).get(v.y + 1), r.nextInt(1000)));\n }\n }\n }\n return vertices;\n }","public Astrocylinders() {\r\n\t\tsuper(CompartmentType.ASTROCYLINDERS.numParams);\r\n\t}","protected void skybox() {\n Triple pos1, pos2, pos3, pos4, pos5, pos6, pos7, pos8, col1, col2, col3, col4;\n\n pos1 = new Triple(0, 0, 0);\n pos2 = new Triple(100, 0, 0);\n pos3 = new Triple(100, 0, 100);\n pos4 = new Triple(0, 0, 100);\n pos5 = new Triple(0, 100, 0);\n pos6 = new Triple(100, 100, 0);\n pos7 = new Triple(100, 100, 100);\n pos8 = new Triple(0, 100, 100);\n\n // Front Triangles\n frozenSoups.addTri( new Triangle(new Vertex(pos1, 0, 0),\n new Vertex(pos2, .25, 0),\n new Vertex(pos3, .25, 1),\n 21 ) );\n\n frozenSoups.addTri( new Triangle(new Vertex(pos3, .25, 1),\n new Vertex(pos4, 0, 1),\n new Vertex(pos1, 0, 0),\n 21 ) );\n\n // Left Triangles\n frozenSoups.addTri( new Triangle(new Vertex(pos1, 1, 0),\n new Vertex(pos5, .75, 0),\n new Vertex(pos8, .75, 1),\n 21 ) );\n\n frozenSoups.addTri( new Triangle(new Vertex(pos8, .75, 1),\n new Vertex(pos4, 1, 1),\n new Vertex(pos1, 1, 0),\n 21 ) );\n\n // Right Triangles\n frozenSoups.addTri( new Triangle(new Vertex(pos2, .25, 0),\n new Vertex(pos6, .5, 0),\n new Vertex(pos7, .5, 1),\n 21 ) );\n\n frozenSoups.addTri( new Triangle(new Vertex(pos7, .5, 1),\n new Vertex(pos3, .25, 1),\n new Vertex(pos2, .25, 0),\n 21 ) );\n\n // Back Triangles\n frozenSoups.addTri( new Triangle(new Vertex(pos5, .75, 0),\n new Vertex(pos6, .5, 0),\n new Vertex(pos7, .5, 1),\n 21 ) );\n\n frozenSoups.addTri( new Triangle(new Vertex(pos7, .5, 1),\n new Vertex(pos8, .75, 1),\n new Vertex(pos5, .75, 0),\n 21 ) );\n\n // Top Triangles\n// frozenSoups.addTri( new Triangle(new Vertex(pos4, 0, 0),\n// new Vertex(pos3, 0, 1),\n// new Vertex(pos7, 1, 1),\n// 20 ) );\n\n// frozenSoups.addTri( new Triangle(new Vertex(pos7, 0, 0),\n// new Vertex(pos8, 1, 0),\n// new Vertex(pos4, 1, 1),\n// 20 ) );\n }","public static List drawCube(Location location1, Location location2, Float density, boolean isBlock) {\n Location loc1 = location1.clone(), loc2 = location2.clone();\n\n loc1.setX(Math.min(location1.getX(),location2.getX()));\n loc1.setY(Math.min(location1.getY(),location2.getY()));\n loc1.setZ(Math.min(location1.getZ(),location2.getZ()));\n loc2.setX(Math.max(location1.getX(),location2.getX()));\n loc2.setY(Math.max(location1.getY(),location2.getY()));\n loc2.setZ(Math.max(location1.getZ(),location2.getZ()));\n\n if (isBlock) {\n loc1 = loc1.getBlock().getLocation();\n loc2 = loc2.getBlock().getLocation();\n loc2.add(1, 1, 1);\n }\n\n double deltaX = Math.abs(loc1.getX() - loc2.getX());\n double deltaY = Math.abs(loc1.getY() - loc2.getY());\n double deltaZ = Math.abs(loc1.getZ() - loc2.getZ());\n\n int dx = (int) Math.ceil(deltaX / density);\n int dy = (int) Math.ceil(deltaY / density);\n int dz = (int) Math.ceil(deltaZ / density);\n\n List collection = new ArrayList<>();\n int[][] var1 = {{0, 0}, {1, 0}, {0, 1}, {1, 1}};\n for (int[] i : var1) {\n Location locx = loc1.clone().add(i[0] * deltaX, 0, i[1] * deltaZ);\n collection.addAll(drawline(locx, locx.clone().add(0, deltaY, 0),dy));\n\n locx = loc1.clone().add(0, i[0] * deltaY, i[1] * deltaZ);\n collection.addAll(drawline(locx, locx.clone().add(deltaX, 0, 0),dx));\n\n locx = loc1.clone().add(i[0] * deltaX, i[1] * deltaY, 0);\n collection.addAll(drawline(locx, locx.clone().add(0, 0, deltaZ),dz));\n }\n return collection;\n }","private RadiusSector() {}","protected Geometry buildShape(\r\n CSGGeometry.CSGOperator\t\tpOperator1\r\n ,\tfloat\t\t\t\t\t\tpLength\r\n ,\tCSGGeometry.CSGOperator\t\tpOperator2\r\n ,\tboolean\t\t\t\t\t\tpRotate\r\n ) {\n Material mat_csg = new Material( assetManager, \"Common/MatDefs/Misc/ShowNormals.j3md\" );\r\n \t//mat_csg.getAdditionalRenderState().setFaceCullMode( FaceCullMode.Off );\r\n\r\n \tCSGGeometry aGeometry = new CSGGeometry();\r\n \taGeometry.setMaterial( mat_csg );\r\n\r\n \tCSGShape aCube = new CSGShape( \"Box\", new Box(1,1,1) );\r\n \tif ( pRotate ) aCube.rotate( 0.4f, 0.4f, 0f );\r\n \taGeometry.addShape( aCube, pOperator1 );\r\n\r\n \tCSGShape aCylinder = new CSGShape( \"Cylinder\", new Cylinder( 32, 32, 1.1f, pLength, true ) );\r\n \taGeometry.addShape( aCylinder, pOperator2 );\r\n \t\r\n \taGeometry.regenerate();\r\n \treturn( aGeometry );\r\n }","public static void test1() {\n int n1 = 100, n2 = 100, n3 = 100;\n float v = 1.0f, d = 20.0f;\n float[][][] paint = new float[n3][n2][n1];\n /*\n for (int i3=0; i3= 0.1f) {\n // normalize direction\n x0 = f0 / swell_height;\n y0 = f1 / swell_height;\n \n float start_arrow = 0.9f * sscale;\n float end_arrow = 1.9f * sscale;\n float arrow_head = 0.3f * sscale;\n x1 = (x + x0 * start_arrow);\n y1 = (y + y0 * start_arrow);\n x2 = (x + x0 * end_arrow);\n y2 = (y + y0 * end_arrow);\n \n // draw arrow shaft\n vx[nv] = x1;\n vy[nv] = y1;\n vz[nv] = z;\n nv++;\n vx[nv] = x2;\n vy[nv] = y2;\n vz[nv] = z;\n nv++;\n \n mbarb[2] = x2;\n mbarb[3] = y2;\n \n xd = x2 - x1;\n yd = y2 - y1;\n \n x3 = x2 - 0.3f * (xd - yd);\n y3 = y2 - 0.3f * (yd + xd);\n x4 = x2 - 0.3f * (xd + yd);\n y4 = y2 - 0.3f * (yd - xd);\n \n // draw arrow head\n vx[nv] = x2;\n vy[nv] = y2;\n vz[nv] = z;\n nv++;\n vx[nv] = x3;\n vy[nv] = y3;\n vz[nv] = z;\n nv++;\n \n vx[nv] = x2;\n vy[nv] = y2;\n vz[nv] = z;\n nv++;\n vx[nv] = x4;\n vy[nv] = y4;\n vz[nv] = z;\n nv++;\n \n int shi = (int) (10.0f * (swell_height + 0.5f));\n float shf = 0.1f * shi;\n String sh_string = Float.toString(shf);\n int point = sh_string.indexOf('.');\n sh_string = sh_string.substring(0, point + 2);\n double[] start = {x, y - 0.25 * sscale, 0.0};\n double[] base = {0.5 * sscale, 0.0, 0.0};\n double[] up = {0.0, 0.5 * sscale, 0.0};\n VisADLineArray array =\n PlotText.render_label(sh_string, start, base, up, true);\n int nl = array.vertexCount;\n int k = 0;\n for (int i=0; i();\n\n ArrayList positions = new ArrayList();\n double step = sector.getDeltaLatDegrees() / this.divisions;\n\n // Generate meridians with labels\n double lon = sector.getMinLongitude().degrees + (this.level == 0 ? 0 : step);\n while (lon < sector.getMaxLongitude().degrees - step / 2)\n {\n Angle longitude = Angle.fromDegrees(lon);\n // Meridian\n positions.clear();\n positions.add(new Position(this.sector.getMinLatitude(), longitude, 0));\n positions.add(new Position(this.sector.getMaxLatitude(), longitude, 0));\n\n Object polyline = createLineRenderable(positions, Polyline.LINEAR);\n Sector sector = Sector.fromDegrees(\n this.sector.getMinLatitude().degrees, this.sector.getMaxLatitude().degrees, lon, lon);\n String lineType = lon == this.sector.getMinLongitude().degrees ?\n GridElement.TYPE_LINE_WEST : GridElement.TYPE_LINE;\n GridElement ge = new GridElement(sector, polyline, lineType);\n ge.value = lon;\n this.gridElements.add(ge);\n\n // Increase longitude\n lon += step;\n }\n\n // Generate parallels\n double lat = this.sector.getMinLatitude().degrees + (this.level == 0 ? 0 : step);\n while (lat < this.sector.getMaxLatitude().degrees - step / 2)\n {\n Angle latitude = Angle.fromDegrees(lat);\n positions.clear();\n positions.add(new Position(latitude, this.sector.getMinLongitude(), 0));\n positions.add(new Position(latitude, this.sector.getMaxLongitude(), 0));\n \n Object polyline = createLineRenderable(positions, Polyline.LINEAR);\n Sector sector = Sector.fromDegrees(\n lat, lat, this.sector.getMinLongitude().degrees, this.sector.getMaxLongitude().degrees);\n String lineType = lat == this.sector.getMinLatitude().degrees ?\n GridElement.TYPE_LINE_SOUTH : GridElement.TYPE_LINE;\n GridElement ge = new GridElement(sector, polyline, lineType);\n ge.value = lat;\n this.gridElements.add(ge);\n\n // Increase latitude\n lat += step;\n }\n }","public int drawV2(int x, int y, int z, int rotationX, int rotationY) {\n\n\t\t\t\tif (debug) {\n\t\t\t\t\tSystem.out.println(\"RotX\" + rotationX);\n\t\t\t\t\tSystem.out.println(\"RotY\" + rotationY);\n\t\t\t\t}\n\n\t\t\t\tint size = ob_size - z;\n\t\t\t\tdouble rotationX_double = (double) rotationX; // cast rotationX as a double (must be a double to do\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t// division)\n\t\t\t\tdouble rotation_X_rad = (rotationX_double / 180) * Math.PI; // convert rotation_X to radians\n\t\t\t\tdouble width_double = size * (Math.cos(rotation_X_rad));\n\t\t\t\tint width = (int) width_double;\n\n\t\t\t\tif (debug)\n\t\t\t\t\tSystem.out.println(\"Width: \" + width);\n\n\t\t\t\tdouble rotationY_double = (double) rotationY; // cast rotationY as a double (must be a double to do\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t// division)\n\t\t\t\tdouble rotation_Y_rad = (rotationY_double / 180) * Math.PI; // convert rotation_Y to radians\n\t\t\t\tdouble height_double = size * (Math.cos(rotation_Y_rad));\n\t\t\t\tint height = (int) height_double;\n\n\t\t\t\tif (debug)\n\t\t\t\t\tSystem.out.println(\"height: \" + height);\n\n\t\t\t\twidth = Math.abs(width);\n\t\t\t\theight = Math.abs(height);\n\n\t\t\t\tint rotate_deviation_X = size - width;\n\t\t\t\tint rotate_deviation_Y = size - height;\n\n\t\t\t\tif (debug) {\n\t\t\t\t\tSystem.out.println(\"RDEVX: \" + rotate_deviation_X);\n\t\t\t\t\tSystem.out.println(\"RDEVY: \" + rotate_deviation_Y);\n\t\t\t\t}\n\n\t\t\t\tpage.drawRect(x, y, width, height); // front edges\n\n\t\t\t\tpage.drawRect(x + rotate_deviation_X, y - rotate_deviation_Y, width, height); // back edges\n\n\t\t\t\tpage.drawLine(x, y, x + (rotate_deviation_X), y - (rotate_deviation_Y)); // top left edge\n\t\t\t\tpage.drawLine(x, y + height, x + (rotate_deviation_X), y - (rotate_deviation_Y) + height); // top right\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t// edge\n\n\t\t\t\tpage.drawLine(x + width, y, x + (rotate_deviation_X) + width, y - (rotate_deviation_Y)); // bottom left\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t// edge\n\t\t\t\tpage.drawLine(x + width, y + height, x + (rotate_deviation_X) + width,\n\t\t\t\t\t\ty - (rotate_deviation_Y) + height); // bottom right edge\n\n\t\t\t\t// ----------------------------------------\n\t\t\t\treturn rotate_deviation_X;\n\t\t\t}","public void makeTriangleBox(int offsetX, int offsetY, int myWidth, int myHeight, int numTriHorizontal, int numTriVertical, int collRect, float[][] verts) {\n //Top Triangles\n for (int i = 0; i < numTriHorizontal; i++) {\n verts[i][0] = (i*myWidth/numTriHorizontal) + offsetX;\n verts[i][1] = offsetY;\n verts[i][2] = ((i+1)*(myWidth/numTriHorizontal)) + offsetX;\n verts[i][3] = offsetY;\n verts[i][4] = (myWidth/(2*numTriHorizontal)) + (i*myWidth/numTriHorizontal) + offsetX;\n if(i%2==0) {\n verts[i][5] = (float) ((Math.sqrt(3) / 2) * (myWidth / numTriHorizontal)) + offsetY;\n } else {\n verts[i][5] = (float)((Math.sqrt(3) / 2) * (myWidth / numTriHorizontal)) + offsetY;\n }\n\n }\n\n //Left Triangles\n\n for (int i = numTriHorizontal; i < (numTriVertical + numTriHorizontal); i++) {\n verts[i][0] = offsetX;\n verts[i][1] = offsetY + ((i-numTriHorizontal) * (myWidth/numTriHorizontal));\n verts[i][2] = offsetX;\n verts[i][3] = offsetY + ((i-(numTriHorizontal-1)) * (myWidth/numTriHorizontal));\n if(i%2==0) {\n verts[i][4] = offsetX + (float) ((Math.sqrt(3) / 2) * (myWidth / numTriHorizontal));\n } else {\n verts[i][4] = offsetX + (float) ((Math.sqrt(3) / 2) * (myWidth / numTriHorizontal));\n }\n verts[i][5] = offsetY + ((i-numTriHorizontal) * (myWidth/numTriHorizontal)) + myWidth/(2*numTriHorizontal);\n\n }\n\n\n //Right Triangles\n for(int i=numTriVertical+numTriHorizontal; i<(2*numTriVertical)+numTriHorizontal; i++) {\n verts[i][0] = width-offsetX;\n verts[i][1] = offsetY + ((i-(numTriVertical+numTriHorizontal)) * (myWidth/numTriHorizontal));\n verts[i][2] = width-offsetX;\n verts[i][3] = offsetY + ((i-(numTriVertical+(numTriHorizontal-1))) * (myWidth/numTriHorizontal));\n if(i%2==0) {\n verts[i][4] = width-(offsetX + (float) ((Math.sqrt(3) / 2) * (myWidth / numTriHorizontal)));\n } else {\n verts[i][4] = width-(offsetX + (float) ((Math.sqrt(3) / 2) * (myWidth / numTriHorizontal)));\n }\n verts[i][5] = offsetY + ((i-(numTriVertical+numTriHorizontal)) * (myWidth/numTriHorizontal)) + myWidth/(2*numTriHorizontal);\n\n }\n\n //Bottom Triangles\n for(int i=(2*numTriVertical)+numTriHorizontal; i<(2*numTriVertical)+(2*numTriHorizontal); i++) {\n verts[i][0] = ((i-((2*numTriVertical)+numTriHorizontal))*myWidth/numTriHorizontal) + offsetX;\n verts[i][1] = (height-100) - offsetY;\n verts[i][2] = ((i-((2*numTriVertical)+numTriHorizontal) +1)*(myWidth/numTriHorizontal)) + offsetX;\n verts[i][3] = (height-100) - offsetY;\n verts[i][4] = (myWidth/(2*numTriHorizontal)) + ((i-((2*numTriVertical)+numTriHorizontal))*myWidth/numTriHorizontal) + offsetX;\n if(i%2==0) {\n verts[i][5] = (float)((height-100) - ( ((Math.sqrt(3) / 2) * (myWidth / numTriHorizontal)) + offsetY));\n } else {\n verts[i][5] = (float)((height-100) - ( ((Math.sqrt(3) / 2) * (myWidth / numTriHorizontal)) + offsetY));\n }\n\n }\n\n }","public void makeSatellite(float radius, int radialDivisions,\n\t\t\tint heightDivisions) {\n\t\tif (radialDivisions < 3)\n\t\t\tradialDivisions = 3;\n\n\t\tif (heightDivisions < 1)\n\t\t\theightDivisions = 1;\n\n\t\tif (heightDivisions > 65)\n\t\t\theightDivisions = 65;\n\n\t\tif (radialDivisions > 65)\n\t\t\tradialDivisions = 65;\n\t//\tSystem.out.println(radialDivisions + \" \" + heightDivisions);\n\n\t\tfloat theta = (float) (2 * Math.PI / radialDivisions);\n\t\tfloat refy = 0.5f;\n\t\tfloat nxty = 1f / heightDivisions;\n\n\t\t// coordinates for the triangle formation\n\t\tfloat x1 = 0;\n\t\tfloat y1 = 0;\n\t\tfloat z1 = 0;\n\t\tfloat x2 = 0;\n\t\tfloat y2 = 0;\n\t\tfloat z2 = 0;\n\t\tfloat x3 = 0;\n\t\tfloat y3 = 0;\n\t\tfloat z3 = 0;\n\t\tfor (int rD = 0; rD < radialDivisions; rD++) {\n\t\t\t//defining coordinates of first point\n\t\t\tx1 = 0f;\n\t\t\ty1 = refy;\n\t\t\tz1 = 0f;\n\t\t\t//defining coordinates of second point\n\t\t\tx2 = (float) (radius * Math.cos(theta * rD));\n\t\t\ty2 = y1;\n\t\t\tz2 = -(float) (radius * Math.sin(theta * rD));\n\t\t\t//defining coordinates of third point\n\t\t\tx3 = (float) (radius * Math.cos(theta * (rD + 1)));\n\t\t\ty3 = y1;\n\t\t\tz3 = -(float) (radius * Math.sin(theta * (rD + 1)));\n\n\t\t\t// tesselation for bottom circle\n\t\t\taddTriangle(x1, y1, z1, 0.0f, 0.0f, x2, y2, z2, 0.0f, 0.0f, x3, y3, z3, 0.0f, 0.0f);\n\n\t\t\ty1 = -y1;\n\n\t\t\tx2 = (float) (radius * Math.cos(theta * (rD + 1)));\n\t\t\ty2 = y1;\n\t\t\tz2 = -(float) (radius * Math.sin(theta * (rD + 1)));\n\n\t\t\tx3 = (float) (radius * Math.cos(theta * (rD)));\n\t\t\ty3 = y1;\n\t\t\tz3 = -(float) (radius * Math.sin(theta * (rD)));\n\n\t\t\t// tesselation for top circle\n\t\t\taddTriangle(x1, y1, z1, 0.0f, 0.0f, x2, y2, z2, 0.0f, 0.0f, x3, y3, z3, 0.0f, 0.0f);\n\n\t\t\ttesselationForCylinder(radius, heightDivisions, theta, refy, nxty,\n\t\t\t\t\trD);\n\t\t}\n\t\t\n\t}","private void paint(int sideLength) {\n\n float fac = randomStart;\n while (sideLength >= 2) {\n\n for (int py = 0; py < _height; py += sideLength) {\n for (int px = 0; px < _width; px += sideLength) {\n // fetch corner colors\n float c1 = mono[repeat(px, py, _width, _height)];\n float c3 = mono[repeat(px + sideLength, py, _width, _height)];\n float c7 = mono[repeat(px, py + sideLength, _width, _height)];\n float c9 = mono[repeat(px + sideLength, py + sideLength, _width,\n _height)];\n\n int shortX = px / sideLength; \n int shortY = py / sideLength; \n \n \n float c2 = (c1 + c3) / 2 + calcFac(fac, shortX, shortY);\n float c4 = (c1 + c7) / 2 + calcFac(fac, shortX, shortY);\n float c5 = (c1 + c3 + c7 + c9) / 4 + calcFac(fac, shortX, shortY);\n\n mono[repeat(px + sideLength / 2, py, _width, _height)] = c2;\n mono[repeat(px, py + sideLength / 2, _width, _height)] = c4;\n mono[repeat(px + sideLength / 2, py + sideLength / 2, _width, _height)] = c5;\n }\n }\n\n fac = fac * randomFactor + randomSummand;\n\n sideLength /= 2;\n }\n }","private static void breadcrumbArrow(int width, int height, int indent, int c1, int c2) {\n\n\t\tdouble x0 = 0, y0 = height / 2d;\n\t\tdouble x1 = indent, y1 = 0;\n\t\tdouble x2 = indent, y2 = height / 2d;\n\t\tdouble x3 = indent, y3 = height;\n\t\tdouble x4 = width, y4 = 0;\n\t\tdouble x5 = width, y5 = height / 2d;\n\t\tdouble x6 = width, y6 = height;\n\t\tdouble x7 = indent + width, y7 = 0;\n\t\tdouble x8 = indent + width, y8 = height;\n\n\t\tint fc1 = ColorHelper.mixAlphaColors(c1, c2, 0);\n\t\tint fc2 = ColorHelper.mixAlphaColors(c1, c2, (indent)/(width + 2f * indent));\n\t\tint fc3 = ColorHelper.mixAlphaColors(c1, c2, (indent + width)/(width + 2f * indent));\n\t\tint fc4 = ColorHelper.mixAlphaColors(c1, c2, 1);\n\n\t\tRenderSystem.disableTexture();\n\t\tRenderSystem.enableBlend();\n\t\tRenderSystem.disableAlphaTest();\n\t\tRenderSystem.defaultBlendFunc();\n\t\tRenderSystem.shadeModel(GL11.GL_SMOOTH);\n\n\t\tTessellator tessellator = Tessellator.getInstance();\n\t\tBufferBuilder bufferbuilder = tessellator.getBuffer();\n\t\tbufferbuilder.begin(GL11.GL_TRIANGLES, DefaultVertexFormats.POSITION_COLOR);\n\n\t\tbufferbuilder.vertex(x0, y0, 0).color(fc1 >> 16 & 0xFF, fc1 >> 8 & 0xFF, fc1 & 0xFF, fc1 >> 24 & 0xFF).endVertex();\n\t\tbufferbuilder.vertex(x1, y1, 0).color(fc2 >> 16 & 0xFF, fc2 >> 8 & 0xFF, fc2 & 0xFF, fc2 >> 24 & 0xFF).endVertex();\n\t\tbufferbuilder.vertex(x2, y2, 0).color(fc2 >> 16 & 0xFF, fc2 >> 8 & 0xFF, fc2 & 0xFF, fc2 >> 24 & 0xFF).endVertex();\n\n\t\tbufferbuilder.vertex(x0, y0, 0).color(fc1 >> 16 & 0xFF, fc1 >> 8 & 0xFF, fc1 & 0xFF, fc1 >> 24 & 0xFF).endVertex();\n\t\tbufferbuilder.vertex(x2, y2, 0).color(fc2 >> 16 & 0xFF, fc2 >> 8 & 0xFF, fc2 & 0xFF, fc2 >> 24 & 0xFF).endVertex();\n\t\tbufferbuilder.vertex(x3, y3, 0).color(fc2 >> 16 & 0xFF, fc2 >> 8 & 0xFF, fc2 & 0xFF, fc2 >> 24 & 0xFF).endVertex();\n\n\t\tbufferbuilder.vertex(x3, y3, 0).color(fc2 >> 16 & 0xFF, fc2 >> 8 & 0xFF, fc2 & 0xFF, fc2 >> 24 & 0xFF).endVertex();\n\t\tbufferbuilder.vertex(x1, y1, 0).color(fc2 >> 16 & 0xFF, fc2 >> 8 & 0xFF, fc2 & 0xFF, fc2 >> 24 & 0xFF).endVertex();\n\t\tbufferbuilder.vertex(x4, y4, 0).color(fc3 >> 16 & 0xFF, fc3 >> 8 & 0xFF, fc3 & 0xFF, fc3 >> 24 & 0xFF).endVertex();\n\n\t\tbufferbuilder.vertex(x3, y3, 0).color(fc2 >> 16 & 0xFF, fc2 >> 8 & 0xFF, fc2 & 0xFF, fc2 >> 24 & 0xFF).endVertex();\n\t\tbufferbuilder.vertex(x4, y4, 0).color(fc3 >> 16 & 0xFF, fc3 >> 8 & 0xFF, fc3 & 0xFF, fc3 >> 24 & 0xFF).endVertex();\n\t\tbufferbuilder.vertex(x6, y6, 0).color(fc3 >> 16 & 0xFF, fc3 >> 8 & 0xFF, fc3 & 0xFF, fc3 >> 24 & 0xFF).endVertex();\n\n\t\tbufferbuilder.vertex(x5, y5, 0).color(fc3 >> 16 & 0xFF, fc3 >> 8 & 0xFF, fc3 & 0xFF, fc3 >> 24 & 0xFF).endVertex();\n\t\tbufferbuilder.vertex(x4, y4, 0).color(fc3 >> 16 & 0xFF, fc3 >> 8 & 0xFF, fc3 & 0xFF, fc3 >> 24 & 0xFF).endVertex();\n\t\tbufferbuilder.vertex(x7, y7, 0).color(fc4 >> 16 & 0xFF, fc4 >> 8 & 0xFF, fc4 & 0xFF, fc4 >> 24 & 0xFF).endVertex();\n\n\t\tbufferbuilder.vertex(x6, y6, 0).color(fc3 >> 16 & 0xFF, fc3 >> 8 & 0xFF, fc3 & 0xFF, fc3 >> 24 & 0xFF).endVertex();\n\t\tbufferbuilder.vertex(x5, y5, 0).color(fc3 >> 16 & 0xFF, fc3 >> 8 & 0xFF, fc3 & 0xFF, fc3 >> 24 & 0xFF).endVertex();\n\t\tbufferbuilder.vertex(x8, y8, 0).color(fc4 >> 16 & 0xFF, fc4 >> 8 & 0xFF, fc4 & 0xFF, fc4 >> 24 & 0xFF).endVertex();\n\n\t\ttessellator.draw();\n\t\tRenderSystem.shadeModel(GL11.GL_FLAT);\n\t\tRenderSystem.disableBlend();\n\t\tRenderSystem.enableAlphaTest();\n\t\tRenderSystem.enableTexture();\n\t}","@SuppressWarnings(\"unused\")\r\n private void JCATsegmentVisceralFat2D01() {\r\n \r\n // get the VOI for the external boundary of the abdomen\r\n VOIVector vois = abdomenImage.getVOIs();\r\n if(vois.size() != 1) {\r\n System.err.println(\"segmentVisceralFat2D() Error, did not get 1 VOI\");\r\n return;\r\n }\r\n\r\n // abdomenImage has one VOI, lets get it\r\n VOI theVOI = vois.get(0);\r\n \r\n // find the center-of-mass of the contour\r\n VOIContour maxContour = ((VOIContour)theVOI.getCurves().get(0));\r\n int[] xVals = new int [maxContour.size()];\r\n int[] yVals = new int [maxContour.size()];\r\n int[] zVals = new int [maxContour.size()];\r\n maxContour.exportArrays(xVals, yVals, zVals);\r\n \r\n int xcm = 0, ycm = 0, zcm = 0;\r\n for (int idx = 0; idx < maxContour.size(); idx++) {\r\n xcm += xVals[idx];\r\n ycm += yVals[idx];\r\n zcm += zVals[idx];\r\n }\r\n \r\n xcm /= maxContour.size();\r\n ycm /= maxContour.size();\r\n zcm /= maxContour.size();\r\n \r\n ViewUserInterface.getReference().getMessageFrame().append(\"Xcm: \" +xcm +\" Ycm: \" +ycm +\" Zcm: \" +zcm+\"\\n\", ViewJFrameMessage.DEBUG);\r\n \r\n // This point should be inside the abdomen\r\n // walk right until you find the external border of the abdomen\r\n \r\n // update the volumeBitSet to match the closed abdomenImage\r\n short[] srcSliceBuffer = new short[sliceSize];\r\n short[] profile = new short[xDim];\r\n try {\r\n abdomenImage.exportData(0, sliceSize, sliceBuffer);\r\n srcImage.exportData(0, sliceSize, srcSliceBuffer);\r\n } catch (IOException ex) {\r\n System.err.println(\"Error exporting data\");\r\n return;\r\n }\r\n\r\n int x = xcm;\r\n int elementCount = 0;\r\n int yOffset = ycm * xDim;\r\n while (x < xDim && sliceBuffer[x + yOffset] == abdomenTissueLabel) {\r\n profile[elementCount] = srcSliceBuffer[x + yOffset];\r\n x++;\r\n elementCount++;\r\n } // end while(...)\r\n \r\n // profile has an intensity profile of the pixels along the ray from the \r\n // contour CM to the external skin boundary. \r\n \r\n \r\n }","private Vector combinationAlgorithm(Stroke theStroke){\n\t\tCurvatureBasedDetection cbd = new CurvatureBasedDetection();\n\t\tSpeedBasedDetection sbd = new SpeedBasedDetection();\n\t\tCommonSegmentPts = new Vector();\n\t\tCurvPts = cbd.getCurvatureData();\n\t\tdouble SpeedPts[][] = sbd.getSpeedData();\n\t\tCurvPtCount = cbd.getIndex();\n\t\tint SpeedPtCount = sbd.getIndex();\n\t\tint index ;\n\t\tCurvVector = new Vector();\n\t\t//copy the speed and curvature data in two vectors\n\t\tfor (index = 0; index < CurvPtCount ; index++){\n\t\t\tDouble obj = CurvPts[index][0];\n\t\t\tCurvVector.add(new Integer(obj.intValue()));\n\t\t}\n\t\t\n\t\tSystem.out.println(\"Curvature Indices\");\n\t\tprintValues(CurvVector);\n\t\t\n\t\tSpeedVector = new Vector();\n\t\tfor (index = 0; index < SpeedPtCount ; index++){\n\t\t\tDouble obj = SpeedPts[index][0];\n\t\t\tSpeedVector.add(new Integer(obj.intValue()));\n\t\t}\n\t\tSystem.out.println(\"Speed Indices\");\n\t\tprintValues(SpeedVector);\n\t\tSort sort = new Sort();\n\t\tint ElementIndex;\n\t\t// find common points (intersection of speed and curvature) and put it in CommonSegmentPts vector\n\t\t\n\t\tboolean flag = false;\n\t\tfor(index = 0; index < SpeedVector.size(); index++ ){\n\t\t\t\n\t\t\tElementIndex = sort.linearSearch(CurvVector, (Integer)SpeedVector.elementAt(index));\n\t\t\t\n\t\t\tif(ElementIndex != -1){\n\t\t\t\tCommonSegmentPts.add((Integer)(CurvVector.elementAt(ElementIndex)));\n\t\t\t\tCurvVector.remove(ElementIndex);\n\t\t\t\tSpeedVector.remove(index --); // point is removed from vectors\n\t\t\t\t\n\t\t\t}\t\t\n\t\t}\n\t\tSystem.out.println(\"Common Points\");\n\t\tprintValues(CommonSegmentPts);\n\t\tint ElemAtIndex;\n\t\t// Find the curvature based segment points in the Tolerance Distance of speed based segment points \n\t\tfor(index = 0; index < SpeedVector.size(); index++ ){\n\t\t\tElementIndex = FindNearbyPts(CurvVector, (Integer)SpeedVector.elementAt(index), theStroke);\n\t\t\tif(ElementIndex != -1){\n\t\t\t\tElemAtIndex = ((Integer)CurvVector.elementAt(ElementIndex) + (Integer)SpeedVector.elementAt(index))/2;\n\t\t\t\tCommonSegmentPts.add(ElemAtIndex);\n\t\t\t\tCurvVector.remove(ElementIndex);\n\t\t\t\tSpeedVector.remove(index--);\n\t\t\t}\n\t\t}\n\t\t//printValues(CommonSegmentPts);\n\t\tremoveNearbyPixels(theStroke);\n\t\t//setNewScalingFactor(theStroke);\n\t\tCollections.sort(CommonSegmentPts);\n\t\tprintValues(CommonSegmentPts);\n\t\tdouble PrevIterError;\n\t\tdouble NewIterError;\n\t\tVector IterationPts = new Vector(); \n\t\t//System.out.println(\"Error \" + (PrevIterError = calculateError(CommonSegmentPts, theStroke)));\n\t\t// create a vector that stores segment points of each iteration\n\t\tIterWiseSegPts = new Vector();\n\t\t// for hybrid\n\t\tIterationPts = copyVector(IterationPts, CommonSegmentPts);\n\t\tdouble PrevError = calculateError(IterationPts, theStroke);\n\t\tif(PrevError > 10000.0){\t// if stroke consists of curves\n\t\t\terrorTolerance = 90.0;\n\t\t}\n\t\tIterationPts.add((double ) PrevError);\n\t\tIterWiseSegPts = appendVector(IterWiseSegPts,IterationPts);\n\t\tdouble NewError = -1;\n/*\t\tint vectorIndex = 0;\n\t\t\n\t\twhile(CurvVector.size()!=0 || SpeedVector.size()!=0){\n\t*/\t\t\n\t\t\t// code for accepting seg points uptil pts reduce the error by 100\n\t\t/*\n\t\t\tif(CurvVector.size()!=0){\n\t\t\t\tint CurvIndex = (Integer)CurvVector.get(0);\n\t\t\t\tCommonSegmentPts.add(CurvIndex);\n\t\t\t\tCurvVector.remove(0);\n\t\t\t\tCollections.sort(CommonSegmentPts);\n\t\t\t\tNewIterError = calculateError(CommonSegmentPts, theStroke);\n\t\t\t\tif((PrevIterError - NewIterError) > 100.0){\n\t\t\t\t\tvectorIndex++;\n\t\t\t\t\tIterWiseSegPts.add(CurvIndex);\n\t\t\t\t\tPrevIterError = NewIterError;\n\t\t\t\t}\n\t\t\t\telse{\n\t\t\t\t\twhile(CurvVector.size()!=0){\n\t\t\t\t\t\tCurvVector.remove(0);\n\t\t\t\t\t}\t\t\t\t\t//return IterWiseSegPts;\n\t\t\t\t}\n\t\t\t}\n\t\t\t\n\t\t\t\n\t\t\tif(SpeedVector.size()!=0){\n\t\t\t\tint SpeedIndex = (Integer)SpeedVector.get(0);\n\t\t\t\tCommonSegmentPts.add(SpeedIndex);\n\t\t\t\tSpeedVector.remove(0);\n\t\t\t\tCollections.sort(CommonSegmentPts);\n\t\t\t\tNewIterError = calculateError(CommonSegmentPts, theStroke);\n\t\t\t\tSystem.out.println(\"New Error = \" + NewIterError);\n\t\t\t//CommonSegmentPts.add((Double)NewIterError);\n\t\t\t\tif((PrevIterError - NewIterError) > 100.0 ){\n\t\t\t\t\tvectorIndex++;\n\t\t\t\t\tIterWiseSegPts.add(SpeedIndex);\n\t\t\t\t\tPrevIterError = NewIterError;\n\t\t\t\t}\n\t\t\t\telse{\n\t\t\t\t\twhile(SpeedVector.size()!=0){\n\t\t\t\t\t\tSpeedVector.remove(0);\n\t\t\t\t\t}\t\t\n\t\t\t\t\t//return IterWiseSegPts;\n\t\t\t\t}\n\t\t\t\n\t\t\t\t\n\t\t\t}*/\n\t\t\t// my approach\n\t/*\t\t\n\t\t\tif(CurvVector.size()!=0){\n\t\t\t\tint Index = findMinimumErrorIndex(CurvVector,CommonSegmentPts,theStroke);\n\t\t\t\tif(Index != -1){\n\t\t\t\tint CurvIndex = (Integer)CurvVector.get(Index);\n\t\t\t\tCommonSegmentPts.add((Integer)CurvIndex);\n\t\t\t\tCurvVector.remove(Index);\n\t\t\t\t}\n\t\t\t\telse{\n\t\t\t\t\tCurvVector = clearVector(CurvVector);\n\t\t\t\t}\n\t\t\t}\n\t\t\tif(SpeedVector.size()!=0){\n\t\t\t\tint Index = findMinimumErrorIndex(SpeedVector,CommonSegmentPts,theStroke);\n\t\t\t\tif(Index != -1){\n\t\t\t\tint SpeedIndex = (Integer)SpeedVector.get(Index);\n\t\t\t\tCommonSegmentPts.add((Integer)SpeedIndex);\n\t\t\t\tSpeedVector.remove(Index);\n\t\t\t\t}\n\t\t\t\telse{\n\t\t\t\t\tSpeedVector = clearVector(SpeedVector);\n\t\t\t\t}\n\t\t\t}\n\t\t\tIterationPts = clearVector(IterationPts);\n\t\t\tIterationPts = copyVector(IterationPts, CommonSegmentPts);\n\t\t\tCollections.sort(IterationPts);\n\t\t\tIterError = calculateError(IterationPts, theStroke);\n\t\t\tIterationPts.add((double) IterError);\n\t\t\tIterWiseSegPts = appendVector(IterWiseSegPts,IterationPts);\n\t\t\tremoveNearbyPixels(theStroke);\n\n\t\t}\n\t\tCommonSegmentPts = clearVector(CommonSegmentPts);\n\t\tCommonSegmentPts = selectBestSegPtsSet(IterWiseSegPts);*/\n\t\t\n\t\t/*\tif(CurvVector.size()!=0){\n\t\tint Index = findMinimumErrorIndex(CurvVector,CommonSegmentPts,theStroke);\n\t\tif(Index != -1){\n\t\tint CurvIndex = (Integer)CurvVector.get(Index);\n\t\tCommonSegmentPts.add((Integer)CurvIndex);\n\t\tCurvVector.remove(Index);\n\t\t}\n\t\telse{\n\t\t\tCurvVector = clearVector(CurvVector);\n\t\t}\n\t}\n\tif(SpeedVector.size()!=0){\n\t\tint Index = findMinimumErrorIndex(SpeedVector,CommonSegmentPts,theStroke);\n\t\tif(Index != -1){\n\t\tint SpeedIndex = (Integer)SpeedVector.get(Index);\n\t\tCommonSegmentPts.add((Integer)SpeedIndex);\n\t\tSpeedVector.remove(Index);\n\t\t}\n\t\telse{\n\t\t\tSpeedVector = clearVector(SpeedVector);\n\t\t}\n\t}\n\tIterationPts = clearVector(IterationPts);\n\tIterationPts = copyVector(IterationPts, CommonSegmentPts);\n\tCollections.sort(IterationPts);\n\tIterError = calculateError(IterationPts, theStroke);\n\tIterationPts.add((double) IterError);\n\tIterWiseSegPts = appendVector(IterWiseSegPts,IterationPts);\n\tremoveNearbyPixels(theStroke);\n\n}\nCommonSegmentPts = clearVector(CommonSegmentPts);\nCommonSegmentPts = selectBestSegPtsSet(IterWiseSegPts);*/\n\t\t\n\t\t\n\t\t// hybrid fit approach\n\t\tint curvIndex = -1, speedIndex = -1;\n\t\tdouble curvError,speedError;\n\t\tVector curvPts = new Vector();\n\t\tVector speedPts = new Vector();\n\t\tVector changeInError = new Vector();\n\t\twhile((CurvVector.size() != 0) || (SpeedVector.size() != 0) ){\n\t\t\tcurvError = DEFAULT;\n\t\t\tspeedError = DEFAULT;\n\t\t\t\n\t\t\tif(CurvVector.size() != 0){\n\t\t\t\tclearVector(curvPts);\n\t\t\t\tcurvPts = copyVector(curvPts, CommonSegmentPts);\n\t\t\t\tcurvIndex = (Integer)CurvVector.get(0);\n\t\t\t\tcurvPts.add((Integer)curvIndex);\n\t\t\t\tCurvVector.remove(0);\n\t\t\t\tCollections.sort(curvPts);\n\t\t\t\tcurvError = calculateError(curvPts, theStroke);\n\t\t\t\tcurvPts.add((Double)curvError);\n\t\t\t}\n\t\t\t\n\t\t\tif(SpeedVector.size() != 0){\n\t\t\t\tclearVector(speedPts);\n\t\t\t\tspeedPts = copyVector(speedPts, CommonSegmentPts);\n\t\t\t\tspeedIndex = (Integer)SpeedVector.get(0);\n\t\t\t\tspeedPts.add((Integer)speedIndex);\n\t\t\t\tSpeedVector.remove(0);\n\t\t\t\tCollections.sort(speedPts);\n\t\t\t\tspeedError = calculateError(speedPts, theStroke);\n\t\t\t\tspeedPts.add((Double)speedError);\n\t\t\t}\n\t\t\t\n\t\t\tif((speedError <= curvError) || (curvError == DEFAULT)){\n\t\t\t\tNewError = speedError;\n\t\t\t\t//changeInError.add((Double)(NewError - PrevError));\n\t\t\t\tif((PrevError - NewError) > errorTolerance){\n\t\t\t\tIterWiseSegPts = appendVector(IterWiseSegPts, speedPts);\n\t\t\t\tCommonSegmentPts.add((Integer)speedIndex);\n\t\t\t\tchangeInError.add((Double)(PrevError - NewError));\n\t\t\t\tPrevError = NewError;\n\t\t\t\t}\n\t\t\t}\n\t\t\telse if((curvError < speedError) || (speedError == DEFAULT)){\n\t\t\t\tNewError = curvError;\n\t\t\t\tif((PrevError - NewError) > errorTolerance){\n\t\t\t\tIterWiseSegPts = appendVector(IterWiseSegPts, curvPts);\n\t\t\t\tCommonSegmentPts.add((Integer)curvIndex);\n\t\t\t\tchangeInError.add((Double)(PrevError - NewError));\n\t\t\t\tPrevError = NewError;\n\t\t\t\t}\n\t\t\t}\n\t\t\n\t\t\t\n\t\t}\n\t\t\t\n\t\tCommonSegmentPts = clearVector(CommonSegmentPts);\n\t\tVector TempVect = new Vector();\n\t\tCommonSegmentPts = copyVectorIndex(IterWiseSegPts, TempVect, IterWiseSegPts.size() - 1);\n\t\t//TempVect = copyVectorIndex(IterWiseSegPts, TempVect, IterWiseSegPts.size() -1);\n\t\t/*index = 0;\n\t\twhile(index < (TempVect.size()-1)){\n\t\t\tCommonSegmentPts.add((Integer)TempVect.get(index++));\n\t\t}*/\n\t\t//CommonSegmentPts = selectBestSegPtsSet(IterWiseSegPts);\n\t\t\n\t\treturn CommonSegmentPts;\n\t}","private void setCofR() {\n\t\t\n Vector3f pos_vec = new Vector3f();\n Point3f pos = new Point3f();\n Vector3f dir = new Vector3f();\n\t\tMatrix4f view_mtx = new Matrix4f();\n\t\tMatrix4f nav_mtx = new Matrix4f();\n Point3f cor = new Point3f();\n\t\t\n\t\tnavigationTransform.getTransform(nav_mtx);\n\t\t\n\t\tdata.viewpointTransform.getTransform(view_mtx);\n\t\tview_mtx.get(pos_vec);\n\t\t\n\t\t// the eye point\n\t\tpos.set(pos_vec);\n\t\t\n\t\t// the eye direction\n\t\tdir.x = view_mtx.m02;\n\t\tdir.y = view_mtx.m12;\n\t\tdir.z = view_mtx.m22;\n\t\tdir.negate();\n\t\tdir.normalize();\n\t\t\n\t\t// transform into world space\n\t\tnav_mtx.transform(pos);\n\t\tnav_mtx.transform(dir);\n\t\t\n\t\tArrayList pickResults = new ArrayList();\n\t\tPickRequest pickRequest = new PickRequest();\n\t\tpickRequest.pickGeometryType = PickRequest.PICK_RAY;\n\t\tpickRequest.pickSortType = PickRequest.SORT_ORDERED;\n\t\tpickRequest.pickType = PickRequest.FIND_GENERAL;\n\t\tpickRequest.useGeometry = false;\n\t\tpickRequest.foundPaths = pickResults;\n\t\t\n\t\t// initialize the pick request\n\t\tpickRequest.origin[0] = pos.x;\n\t\tpickRequest.origin[1] = pos.y;\n\t\tpickRequest.origin[2] = pos.z;\n\t\t\n\t\tpickRequest.destination[0] = dir.x;\n\t\tpickRequest.destination[1] = dir.y;\n\t\tpickRequest.destination[2] = dir.z;\n\t\t\n\t\trootGroup.pickSingle(pickRequest);\n\t\t\n\t\tif (pickRequest.pickCount > 0) {\n\t\t\t\n \tPoint3f intersectPoint = new Point3f();\n \tVector3f intersectVector = new Vector3f();\n\t\t\n\t\t\tfloat min_distance = Float.MAX_VALUE;\n\t\t\t// sort through the bounds intersections\n\t\t\tint num_pick = pickResults.size();\n\t\t\tfor (int i = 0; i < num_pick; i++) {\n\t\t\t\t\n\t\t\t\tSceneGraphPath sgp = (SceneGraphPath)pickResults.get(i);\n\t\t\t\tsgp.getTransform(view_mtx);\n\t\t\t\t\n\t\t\t\tShape3D shape = (Shape3D)sgp.getTerminalNode();\n\t\t\t\tVertexGeometry geom = (VertexGeometry)shape.getGeometry();\n\t\t\t\t\n\t\t\t\t//determine if there was an actual geometry intersection\n\t\t\t\tboolean intersect = iutils.rayUnknownGeometry(\n\t\t\t\t\tpos,\n\t\t\t\t\tdir,\n\t\t\t\t\t0,\n\t\t\t\t\tgeom,\n\t\t\t\t\tview_mtx,\n\t\t\t\t\tintersectPoint,\n\t\t\t\t\tfalse);\n\t\t\t\t\n\t\t\t\tif (intersect) {\n\t\t\t\t\tintersectVector.set(\n\t\t\t\t\t\tintersectPoint.x - pos.x,\n\t\t\t\t\t\tintersectPoint.y - pos.y,\n\t\t\t\t\t\tintersectPoint.z - pos.z);\n\n\t\t\t\t\tfloat distance = intersectVector.length();\n\t\t\t\t\tif (distance < min_distance) {\n\t\t\t\t\t\tmin_distance = distance;\n\t\t\t\t\t\tcor.set(intersectPoint);\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t} \n\t\t\tnav_mtx.invert();\n\t\t\tnav_mtx.transform(cor);\n\t\t}\n\t\tcenterOfRotation.set(cor);\n\t}","public BranchGroup cubo2(){\n\t\t\tBranchGroup objRoot = new BranchGroup();\n\n\t TransformGroup objScale = new TransformGroup();\n\t Transform3D t3d = new Transform3D();\n\t Transform3D rotate = new Transform3D();\n Transform3D tempRotate = new Transform3D();\n\t \t rotate.rotX(Math.PI/1.0d);\n tempRotate.rotY(Math.PI/1.80d);\n Matrix3d n = new Matrix3d();\n Vector3d op = new Vector3d(.2,.05,.2);\n tempRotate.setScale(op);\n Vector3d op2 = new Vector3d(.5,.6,.5);\n tempRotate.setTranslation(op2);\n rotate.mul(tempRotate);\n // rotate.mul(objScale);\n TransformGroup objRotate = new TransformGroup(rotate);\n \n //objRotate.addChild(new ColorCube(0.4));\n objRoot.addChild(objRotate);\n\t \n t3d.mul(rotate);\n\t objScale.setTransform(t3d);\n\t \n\t objRoot.addChild(objScale);\n\n\tTransformGroup objTrans = new TransformGroup();\n\t\tobjTrans.setCapability(TransformGroup.ALLOW_TRANSFORM_WRITE);\n\t\tobjTrans.setCapability(TransformGroup.ALLOW_TRANSFORM_READ);\n\t\t\t\t\t\n\t\t\n\t\tobjScale.addChild(objTrans);\n\n\t\tint flags = ObjectFile.RESIZE;\n\t\tif (!noTriangulate) flags |= ObjectFile.TRIANGULATE;\n\t\tif (!noStripify) flags |= ObjectFile.STRIPIFY;\n\t\tObjectFile f = new ObjectFile(flags, \n\t\t (float)(creaseAngle * Math.PI / 180.0));\n\t\tScene s = null;\n\t\ttry {\n\t\t s = f.load(filename);\n\t\t}\n\t\tcatch (FileNotFoundException e) {\n\t\t System.err.println(e);\n\t\t System.exit(1);\n\t\t}\n\t\tcatch (ParsingErrorException e) {\n\t\t System.err.println(e);\n\t\t System.exit(1);\n\t\t}\n\t\tcatch (IncorrectFormatException e) {\n\t\t System.err.println(e);\n\t\t System.exit(1);\n\t\t}\n\t\t \n\t\tobjTrans.addChild(s.getSceneGroup());\n\t\t\n \n \n\t\tBoundingSphere bounds = new BoundingSphere(new Point3d(0.0,0.0,0.0), 100.0);\n\n\n\t \n\t // Set up the background\n\t Color3f bgColor = new Color3f(0.05f, 0.05f, 0.5f);\n\t Background bgNode = new Background(bgColor);\n\t bgNode.setApplicationBounds(bounds);\n\t objRoot.addChild(bgNode);\n\n\t\treturn objRoot;\n\t\t \n\t }","private boolean isOnCylinder(Point3D point) {\n // the vector from bottom to the point\n Vector vec1 = new Vector(Point3D.substract(orientation.getPOO(), point));\n\n // the vector from the top to point\n Vector vec2 = new Vector(Point3D.substract(top, point));\n\n // the vectors to the edges of cylinder\n Vector vec3 = new Vector(Point3D.substract(orientation.getPOO(), point));\n\n Vector vec4 = new Vector(Point3D.substract(top, point));\n\n double Vec3dot = Vector.dotProduct(vec3, orientation.getDirection());\n\n double Vec4dot = Vector.dotProduct(vec4, orientation.getDirection());\n if (Vec3dot == 0)\n if (_radius - vec3.length() >= 0)\n return true;\n if (Vec4dot == 0)\n if (_radius - vec4.length() >= 0)\n return true;\n\n if (Vector.dotProduct(vec1, orientation.getDirection()) > 0\n && Vector.dotProduct(vec2, orientation.getDirection()) < 0)\n return true;\n return false;\n }","public void lungs(Graphics bbg, int n, int length, int x, int y, double angle){\n double r1 = angle + Math.toRadians(-45);\n double r2 = angle + Math.toRadians(45);\n double r3 = angle + Math.toRadians(135);\n double r4 = angle + Math.toRadians(-135);\n\n //length modifications of the different branches\n double l1 = length/1.3 + (l1I*5);\n double l2 = length/1.3 + (l2I*5);\n double l3 = length/1.3 + (l3I*5);\n double l4 = length/1.3 + (l4I*5);\n\n //x and y points of the end of the different branches\n int ax = (int)(x - Math.sin(r1)*l1)+(int)(l1I);\n int ay = (int)(y - Math.cos(r1)*l1)+(int)(l1I);\n int bx = (int)(x - Math.sin(r2)*l2)+(int)(l2I);\n int by = (int)(y - Math.cos(r2)*l2)+(int)(l2I);\n int cx = (int)(x - Math.sin(r3)*l3)+(int)(l3I);\n int cy = (int)(y - Math.cos(r3)*l3)+(int)(l3I);\n int dx = (int)(x - Math.sin(r4)*l4)+(int)(l4I);\n int dy = (int)(y - Math.cos(r4)*l4)+(int)(l4I);\n\n if(n == 0){\n return;\n }\n\n\n increment();\n Color fluidC = new Color(colorR,colorG,colorB);\n //bbg.setColor(new Color((int) (Math.random() * 255), (int) (Math.random() * 255), (int) (Math.random()*255)));\n bbg.setColor(fluidC);\n\n\n //draw different branches\n bbg.drawLine(x,y,ax,ay);\n bbg.drawLine(x,y,bx,by);\n bbg.drawLine(x,y,cx,cy);\n bbg.drawLine(x,y,dx,dy);\n\n\n\n //call recursively to draw fractal\n lungs(bbg, n - 1, (int)l1, ax,ay,r1);\n lungs(bbg, n - 1, (int)l2, bx,by,r2);\n lungs(bbg, n - 1, (int)l3, cx,cy,r3);\n lungs(bbg, n - 1, (int)l4, dx,dy,r4);\n\n\n }","public void ignoreCreateArrayForVec2With6Position() {\r\n\r\n SXRMesh sxrMesh = TestDefaultSXRViewManager.mSXRContext.getAssetLoader().loadMesh(UtilResource.androidResource(TestDefaultSXRViewManager.mSXRContext,R.raw.cylinder3));\r\n float[] vec2 = {-0.5f, 0.5f, 0.0f, -0.5f, 0.5f, 0.0f};\r\n\r\n try {\r\n sxrMesh.setVec3Vector(\"ratio_r\", vec2);\r\n assertNotNull(sxrMesh.getVec4Vector(\"ratio_r\"));\r\n fail();\r\n } catch (Exception e) {\r\n assertEquals(e.getMessage(), \"setVec2Vector method support only three position array\");\r\n }\r\n }","public CircularGrid(int ringCount, boolean verticalCut, boolean horizontalCut) {\r\n\t\tif (ringCount<0)\r\n\t\t\tthrow new IllegalArgumentException(\"The number of rings is illegal: \"+ringCount);\r\n\t\tint columnCount = 2*(ringCount-1) + ((verticalCut)?2:1);\r\n\t\tint rowCount = 2*(ringCount-1) + ((horizontalCut)?2:1);\r\n\t\tinit(columnCount, rowCount);\r\n\t}","private static double[][] makeRegularPoly(double centerLat, double centerLon, double radiusMeters, int gons) {\n\n double[][] result = new double[2][];\n result[0] = new double[gons+1];\n result[1] = new double[gons+1];\n for(int i=0;i radiusMeters) {\n // too big\n //System.out.println(\" smaller\");\n factor -= step;\n if (last == 1) {\n //System.out.println(\" half-step\");\n step /= 2.0;\n }\n last = -1;\n } else if (distanceMeters < radiusMeters) {\n // too small\n //System.out.println(\" bigger\");\n factor += step;\n if (last == -1) {\n //System.out.println(\" half-step\");\n step /= 2.0;\n }\n last = 1;\n }\n }\n }\n\n // close poly\n result[0][gons] = result[0][0];\n result[1][gons] = result[1][0];\n\n return result;\n }","protected void building(double xCoord, double yCoord, double len, double width, double height)\n {\n double x1 = (xCoord - (width/2)); // Low x\n double x2 = (xCoord + (width/2)); // High x\n double y1 = (yCoord - (len/2)); // Low y\n double y2 = (yCoord + (len/2)); // High y\n\n Vertex vertex1, vertex2, vertex3;\n\n Triple pos1, pos2, pos3, pos4, pos5, pos6, pos7, pos8, col1, col2, col3, col4;\n Vertex vert1, vert2, vert3;\n\n pos1 = new Triple(x1, y1, 0); \n pos2 = new Triple(x2, y1, 0); \n pos3 = new Triple(x2, y1, height);\n pos4 = new Triple(x1, y1, height);\n pos5 = new Triple(x1, y2, 0); \n pos6 = new Triple(x2, y2, 0); \n pos7 = new Triple(x2, y2, height);\n pos8 = new Triple(x1, y2, height);\n\n col1 = new Triple(1, 0, 0); \n col2 = new Triple(0, 1, 0); \n col3 = new Triple(0, 0, 1); \n col4 = new Triple(1, 0, 1); \n \n // Front Triangles\n frozenSoups.addTri( new Triangle(new Vertex(pos1, 0, 0), \n new Vertex(pos2, 0, 1), \n new Vertex(pos3, 1, 1), \n\t\t\t\t 25 ) );\n\n frozenSoups.addTri( new Triangle(new Vertex(pos3, 1, 1), \n new Vertex(pos4, 1, 0), \n new Vertex(pos1, 0, 0),\n 25 ) );\n \n // Left Triangles\n frozenSoups.addTri( new Triangle(new Vertex(pos1, 0, 0), \n new Vertex(pos5, 0, 1), \n new Vertex(pos8, 1, 1),\n 26 ) );\n\n frozenSoups.addTri( new Triangle(new Vertex(pos8, 1, 1), \n new Vertex(pos4, 1, 0), \n new Vertex(pos1, 0, 0),\n 26 ) );\n\n // Right Triangles\n frozenSoups.addTri( new Triangle(new Vertex(pos2, 0, 0), \n new Vertex(pos6, 0, 1), \n new Vertex(pos7, 1, 1),\n 24 ) );\n\n frozenSoups.addTri( new Triangle(new Vertex(pos7, 1, 1), \n new Vertex(pos3, 1, 0), \n new Vertex(pos2, 0, 0),\n 24 ) );\n\n // Back Triangles\n frozenSoups.addTri( new Triangle(new Vertex(pos5, 0, 0), \n new Vertex(pos6, 0, 1), \n new Vertex(pos7, 1, 1),\n 27 ) );\n\n frozenSoups.addTri( new Triangle(new Vertex(pos7, 1, 1), \n new Vertex(pos8, 1, 0), \n new Vertex(pos5, 0, 0),\n 27 ) );\n\n // Top Triangles\n frozenSoups.addTri( new Triangle(new Vertex(pos4, 0, 0), \n new Vertex(pos3, 0, 1), \n new Vertex(pos7, 1, 1),\n 28 ) );\n\n frozenSoups.addTri( new Triangle(new Vertex(pos7, 1, 1), \n new Vertex(pos8, 1, 0), \n new Vertex(pos4, 0, 0),\n 28 ) );\n }","public DynamicModelPart addCuboids() {\n for (int i = 0; i < this.x.length; i++) {\n this.addCuboid(this.x[i], this.y[i], this.z[i], this.sizeX[i], this.sizeY[i],\n this.sizeZ[i], this.extra[i], this.u[i], this.v[i]);\n }\n return this;\n }","public void constructBoundingBox()\r\n\t{\n\t\tdouble a = m_Qmin.x;\r\n\t\tdouble b = m_Qmin.y;\r\n\t\tdouble c = m_Qmin.z;\r\n\r\n\t\tdouble d = m_Qmax.x;\r\n\t\tdouble e = m_Qmax.y;\r\n\t\tdouble f = m_Qmax.z;\r\n\r\n\t\t//constructing the vertexes of the bounding box\r\n\t\tSceneVertex A = new SceneVertex( new Vector3d(a, b, c));\r\n\t\tSceneVertex B = new SceneVertex( new Vector3d(d, b, c));\r\n\t\tSceneVertex C = new SceneVertex( new Vector3d(d, b, f));\r\n\t\tSceneVertex D = new SceneVertex( new Vector3d(d, e, f));\r\n\t\tSceneVertex E = new SceneVertex( new Vector3d(a, e, f));\r\n\t\tSceneVertex F = new SceneVertex( new Vector3d(a, e, c));\r\n\t\tSceneVertex G = new SceneVertex( new Vector3d(d, e, c));\r\n\t\tSceneVertex H = new SceneVertex( new Vector3d(a, b, f));\r\n\r\n\r\n\t\t// building the vertices arrays for the faces\r\n\t\tArrayList verArrP0front = new ArrayList(4);\r\n\t\tverArrP0front.add(A);\r\n\t\tverArrP0front.add(B);\r\n\t\tverArrP0front.add(G);\r\n\t\tverArrP0front.add(F);\r\n\t\t\r\n\t\tArrayList verArrP1left = new ArrayList(4);\r\n\t\tverArrP1left.add(A);\r\n\t\tverArrP1left.add(F);\r\n\t\tverArrP1left.add(E);\r\n\t\tverArrP1left.add(H);\r\n\t\t\r\n\t\tArrayList verArrP2back = new ArrayList(4);\r\n\t\tverArrP2back.add(H);\r\n\t\tverArrP2back.add(C);\r\n\t\tverArrP2back.add(D);\r\n\t\tverArrP2back.add(E);\r\n\t\t\r\n\t\tArrayList verArrP3right = new ArrayList(4);\r\n\t\tverArrP3right.add(G);\r\n\t\tverArrP3right.add(D);\r\n\t\tverArrP3right.add(C);\r\n\t\tverArrP3right.add(B);\r\n\t\t\r\n\t\tArrayList verArrP4bottom = new ArrayList(4);\r\n\t\tverArrP4bottom.add(A);\r\n\t\tverArrP4bottom.add(H);\r\n\t\tverArrP4bottom.add(C);\r\n\t\tverArrP4bottom.add(B);\r\n\r\n\t\tArrayList verArrP5top = new ArrayList(4);\r\n\t\tverArrP5top.add(F);\r\n\t\tverArrP5top.add(G);\r\n\t\tverArrP5top.add(D);\r\n\t\tverArrP5top.add(E);\r\n\t\t\r\n\t\t// creating BoundingBox\r\n\t\tm_BoundingBox = new SceneNode(DrawingMode.GL_LINE, \"BoundingBox\", null);\r\n\t\tm_BoundingBox.addChild( new ScenePolygon(verArrP0front, \"FRONT\"));\r\n\t\tm_BoundingBox.addChild( new ScenePolygon(verArrP1left, \"LEFT\"));\r\n\t\tm_BoundingBox.addChild( new ScenePolygon(verArrP2back, \"BACK\"));\r\n\t\tm_BoundingBox.addChild( new ScenePolygon(verArrP3right, \"RIGHT\"));\r\n\t\tm_BoundingBox.addChild( new ScenePolygon(verArrP4bottom, \"BOTTOM\"));\r\n\t\tm_BoundingBox.addChild( new ScenePolygon(verArrP5top, \"TOP\"));\r\n\r\n\t\t\r\n\t}","public Triangle (double x1,double y1,double x2, double y2)\r\n {\r\n v1 = new Point(x1,y1);\r\n v2 = new Point(x2,y2);\r\n v3 = new Point(0,0);\r\n }","public void drawNearClippedFace(int face) {\n\t\tint centerX = Draw3D.centerX;\n\t\tint centerY = Draw3D.centerY;\n\t\tint elements = 0;\n\n\t\tint a = faceVertexA[face];\n\t\tint b = faceVertexB[face];\n\t\tint c = faceVertexC[face];\n\n\t\tint zA = vertexViewSpaceZ[a];\n\t\tint zB = vertexViewSpaceZ[b];\n\t\tint zC = vertexViewSpaceZ[c];\n\n\t\tif (zA >= 50) {\n\t\t\tclippedX[elements] = vertexScreenX[a];\n\t\t\tclippedY[elements] = vertexScreenY[a];\n\t\t\tclippedColor[elements++] = faceColorA[face];\n\t\t} else {\n\t\t\tint xA = vertexViewSpaceX[a];\n\t\t\tint yA = vertexViewSpaceY[a];\n\t\t\tint colorA = faceColorA[face];\n\n\t\t\tif (zC >= 50) {\n\t\t\t\tint scalar = (50 - zA) * reciprical16[zC - zA];\n\t\t\t\tclippedX[elements] = centerX + (((xA + (((vertexViewSpaceX[c] - xA) * scalar) >> 16)) << 9) / 50);\n\t\t\t\tclippedY[elements] = centerY + (((yA + (((vertexViewSpaceY[c] - yA) * scalar) >> 16)) << 9) / 50);\n\t\t\t\tclippedColor[elements++] = colorA + (((faceColorC[face] - colorA) * scalar) >> 16);\n\t\t\t}\n\n\t\t\tif (zB >= 50) {\n\t\t\t\tint scalar = (50 - zA) * reciprical16[zB - zA];\n\t\t\t\tclippedX[elements] = centerX + (((xA + (((vertexViewSpaceX[b] - xA) * scalar) >> 16)) << 9) / 50);\n\t\t\t\tclippedY[elements] = centerY + (((yA + (((vertexViewSpaceY[b] - yA) * scalar) >> 16)) << 9) / 50);\n\t\t\t\tclippedColor[elements++] = colorA + (((faceColorB[face] - colorA) * scalar) >> 16);\n\t\t\t}\n\t\t}\n\n\t\tif (zB >= 50) {\n\t\t\tclippedX[elements] = vertexScreenX[b];\n\t\t\tclippedY[elements] = vertexScreenY[b];\n\t\t\tclippedColor[elements++] = faceColorB[face];\n\t\t} else {\n\t\t\tint xB = vertexViewSpaceX[b];\n\t\t\tint yB = vertexViewSpaceY[b];\n\t\t\tint colorB = faceColorB[face];\n\n\t\t\tif (zA >= 50) {\n\t\t\t\tint scalar = (50 - zB) * reciprical16[zA - zB];\n\t\t\t\tclippedX[elements] = centerX + (((xB + (((vertexViewSpaceX[a] - xB) * scalar) >> 16)) << 9) / 50);\n\t\t\t\tclippedY[elements] = centerY + (((yB + (((vertexViewSpaceY[a] - yB) * scalar) >> 16)) << 9) / 50);\n\t\t\t\tclippedColor[elements++] = colorB + (((faceColorA[face] - colorB) * scalar) >> 16);\n\t\t\t}\n\n\t\t\tif (zC >= 50) {\n\t\t\t\tint scalar = (50 - zB) * reciprical16[zC - zB];\n\t\t\t\tclippedX[elements] = centerX + (((xB + (((vertexViewSpaceX[c] - xB) * scalar) >> 16)) << 9) / 50);\n\t\t\t\tclippedY[elements] = centerY + (((yB + (((vertexViewSpaceY[c] - yB) * scalar) >> 16)) << 9) / 50);\n\t\t\t\tclippedColor[elements++] = colorB + (((faceColorC[face] - colorB) * scalar) >> 16);\n\t\t\t}\n\t\t}\n\n\t\tif (zC >= 50) {\n\t\t\tclippedX[elements] = vertexScreenX[c];\n\t\t\tclippedY[elements] = vertexScreenY[c];\n\t\t\tclippedColor[elements++] = faceColorC[face];\n\t\t} else {\n\t\t\tint xC = vertexViewSpaceX[c];\n\t\t\tint yC = vertexViewSpaceY[c];\n\t\t\tint colorC = faceColorC[face];\n\n\t\t\tif (zB >= 50) {\n\t\t\t\tint k6 = (50 - zC) * reciprical16[zB - zC];\n\t\t\t\tclippedX[elements] = centerX + (((xC + (((vertexViewSpaceX[b] - xC) * k6) >> 16)) << 9) / 50);\n\t\t\t\tclippedY[elements] = centerY + (((yC + (((vertexViewSpaceY[b] - yC) * k6) >> 16)) << 9) / 50);\n\t\t\t\tclippedColor[elements++] = colorC + (((faceColorB[face] - colorC) * k6) >> 16);\n\t\t\t}\n\n\t\t\tif (zA >= 50) {\n\t\t\t\tint l6 = (50 - zC) * reciprical16[zA - zC];\n\t\t\t\tclippedX[elements] = centerX + (((xC + (((vertexViewSpaceX[a] - xC) * l6) >> 16)) << 9) / 50);\n\t\t\t\tclippedY[elements] = centerY + (((yC + (((vertexViewSpaceY[a] - yC) * l6) >> 16)) << 9) / 50);\n\t\t\t\tclippedColor[elements++] = colorC + (((faceColorA[face] - colorC) * l6) >> 16);\n\t\t\t}\n\t\t}\n\n\t\tint x0 = clippedX[0];\n\t\tint x1 = clippedX[1];\n\t\tint x2 = clippedX[2];\n\t\tint y0 = clippedY[0];\n\t\tint y1 = clippedY[1];\n\t\tint y2 = clippedY[2];\n\n\t\t// Back-face culling\n\t\tif ((((x0 - x1) * (y2 - y1)) - ((y0 - y1) * (x2 - x1))) <= 0) {\n\t\t\treturn;\n\t\t}\n\n\t\tDraw3D.clipX = false;\n\n\t\t// It's possible for a single triangle to be clipped into two separate triangles.\n\n\t\tif (elements == 3) {\n\t\t\tif ((x0 < 0) || (x1 < 0) || (x2 < 0) || (x0 > Draw2D.boundX) || (x1 > Draw2D.boundX) || (x2 > Draw2D.boundX)) {\n\t\t\t\tDraw3D.clipX = true;\n\t\t\t}\n\n\t\t\tint type;\n\n\t\t\tif (faceInfo == null) {\n\t\t\t\ttype = 0;\n\t\t\t} else {\n\t\t\t\ttype = faceInfo[face] & 3;\n\t\t\t}\n\n\t\t\tif (type == 0) {\n\t\t\t\tDraw3D.fillGouraudTriangle(y0, y1, y2, x0, x1, x2, clippedColor[0], clippedColor[1], clippedColor[2]);\n\t\t\t} else if (type == 1) {\n\t\t\t\tDraw3D.fillTriangle(y0, y1, y2, x0, x1, x2, palette[faceColorA[face]]);\n\t\t\t} else if (type == 2) {\n\t\t\t\tint texturedFace = faceInfo[face] >> 2;\n\t\t\t\tint tA = texturedVertexA[texturedFace];\n\t\t\t\tint tB = texturedVertexB[texturedFace];\n\t\t\t\tint tC = texturedVertexC[texturedFace];\n\t\t\t\tDraw3D.fillTexturedTriangle(y0, y1, y2, x0, x1, x2, clippedColor[0], clippedColor[1], clippedColor[2], vertexViewSpaceX[tA], vertexViewSpaceX[tB], vertexViewSpaceX[tC], vertexViewSpaceY[tA], vertexViewSpaceY[tB], vertexViewSpaceY[tC], vertexViewSpaceZ[tA], vertexViewSpaceZ[tB], vertexViewSpaceZ[tC], faceColor[face]);\n\t\t\t} else if (type == 3) {\n\t\t\t\tint texturedFace = faceInfo[face] >> 2;\n\t\t\t\tint tA = texturedVertexA[texturedFace];\n\t\t\t\tint tB = texturedVertexB[texturedFace];\n\t\t\t\tint tC = texturedVertexC[texturedFace];\n\t\t\t\tDraw3D.fillTexturedTriangle(y0, y1, y2, x0, x1, x2, faceColorA[face], faceColorA[face], faceColorA[face], vertexViewSpaceX[tA], vertexViewSpaceX[tB], vertexViewSpaceX[tC], vertexViewSpaceY[tA], vertexViewSpaceY[tB], vertexViewSpaceY[tC], vertexViewSpaceZ[tA], vertexViewSpaceZ[tB], vertexViewSpaceZ[tC], faceColor[face]);\n\t\t\t}\n\t\t} else if (elements == 4) {\n\t\t\tif ((x0 < 0) || (x1 < 0) || (x2 < 0) || (x0 > Draw2D.boundX) || (x1 > Draw2D.boundX) || (x2 > Draw2D.boundX) || (clippedX[3] < 0) || (clippedX[3] > Draw2D.boundX)) {\n\t\t\t\tDraw3D.clipX = true;\n\t\t\t}\n\n\t\t\tint type;\n\n\t\t\tif (faceInfo == null) {\n\t\t\t\ttype = 0;\n\t\t\t} else {\n\t\t\t\ttype = faceInfo[face] & 3;\n\t\t\t}\n\n\t\t\tif (type == 0) {\n\t\t\t\tDraw3D.fillGouraudTriangle(y0, y1, y2, x0, x1, x2, clippedColor[0], clippedColor[1], clippedColor[2]);\n\t\t\t\tDraw3D.fillGouraudTriangle(y0, y2, clippedY[3], x0, x2, clippedX[3], clippedColor[0], clippedColor[2], clippedColor[3]);\n\t\t\t} else if (type == 1) {\n\t\t\t\tint colorA = palette[faceColorA[face]];\n\t\t\t\tDraw3D.fillTriangle(y0, y1, y2, x0, x1, x2, colorA);\n\t\t\t\tDraw3D.fillTriangle(y0, y2, clippedY[3], x0, x2, clippedX[3], colorA);\n\t\t\t} else if (type == 2) {\n\t\t\t\tint texturedFace = faceInfo[face] >> 2;\n\t\t\t\tint tA = texturedVertexA[texturedFace];\n\t\t\t\tint tB = texturedVertexB[texturedFace];\n\t\t\t\tint tC = texturedVertexC[texturedFace];\n\t\t\t\tDraw3D.fillTexturedTriangle(y0, y1, y2, x0, x1, x2, clippedColor[0], clippedColor[1], clippedColor[2], vertexViewSpaceX[tA], vertexViewSpaceX[tB], vertexViewSpaceX[tC], vertexViewSpaceY[tA], vertexViewSpaceY[tB], vertexViewSpaceY[tC], vertexViewSpaceZ[tA], vertexViewSpaceZ[tB], vertexViewSpaceZ[tC], faceColor[face]);\n\t\t\t\tDraw3D.fillTexturedTriangle(y0, y2, clippedY[3], x0, x2, clippedX[3], clippedColor[0], clippedColor[2], clippedColor[3], vertexViewSpaceX[tA], vertexViewSpaceX[tB], vertexViewSpaceX[tC], vertexViewSpaceY[tA], vertexViewSpaceY[tB], vertexViewSpaceY[tC], vertexViewSpaceZ[tA], vertexViewSpaceZ[tB], vertexViewSpaceZ[tC], faceColor[face]);\n\t\t\t} else if (type == 3) {\n\t\t\t\tint texturedFace = faceInfo[face] >> 2;\n\t\t\t\tint tA = texturedVertexA[texturedFace];\n\t\t\t\tint tB = texturedVertexB[texturedFace];\n\t\t\t\tint tC = texturedVertexC[texturedFace];\n\t\t\t\tDraw3D.fillTexturedTriangle(y0, y1, y2, x0, x1, x2, faceColorA[face], faceColorA[face], faceColorA[face], vertexViewSpaceX[tA], vertexViewSpaceX[tB], vertexViewSpaceX[tC], vertexViewSpaceY[tA], vertexViewSpaceY[tB], vertexViewSpaceY[tC], vertexViewSpaceZ[tA], vertexViewSpaceZ[tB], vertexViewSpaceZ[tC], faceColor[face]);\n\t\t\t\tDraw3D.fillTexturedTriangle(y0, y2, clippedY[3], x0, x2, clippedX[3], faceColorA[face], faceColorA[face], faceColorA[face], vertexViewSpaceX[tA], vertexViewSpaceX[tB], vertexViewSpaceX[tC], vertexViewSpaceY[tA], vertexViewSpaceY[tB], vertexViewSpaceY[tC], vertexViewSpaceZ[tA], vertexViewSpaceZ[tB], vertexViewSpaceZ[tC], faceColor[face]);\n\t\t\t}\n\t\t}\n\t}","private static double[] makePolygon() {\n double[] polygon = new double[POINTS*2];\n \n for (int i = 0; i < POINTS; i++) {\n double a = i * Math.PI * 2.0 / POINTS;\n polygon[2*i] = Math.cos(a);\n polygon[2*i+1] = Math.sin(a);\n }\n \n return polygon;\n }","private Mesh createMesh(final int pTrianglesCount) {\n\t\tfinal int pSpeed \t\t\t= 20;\n\t\tfinal int pVertexCount\t \t= Mesh.VERTEX_SIZE * pTrianglesCount * 3; \t\n\t\tfinal float pColor \t\t\t= new Color(0f,0f,0f).getABGRPackedFloat();\n\t\tfinal float pSegmentWidth \t= CAMERA_WIDTH/pTrianglesCount;\n\t\tfinal float[] pBufferData \t= new float[pVertexCount];\t\n\t\t\n\t\tmHeightOffsetCurrent = new float[pVertexCount];\t\t\n\t\t\n\t\t//create triangles \n\t\t// A--B\n\t\t// \\ |\n\t\t// \\|\n\t\t// C\n\t\t//\n\t\tint i = 0;\n\t\tfloat x = 0f;\n\t\tfinal float pInitialHeight = 400;\n\t\tfor (int triangleIndex = 0;triangleIndex0){ \n//\t\t\t\t\t\t\tmHeightOffsetCurrent[i] = mHeightOffsetCurrent[i-2];\n//\t\t\t\t\t\t} else { \n//\t\t\t\t\t\t\tmHeightOffsetCurrent[i] = getNormalizedSine(i+progress_x, mTouchY, pTrianglesCount*3);\n//\t\t\t\t\t\t}\n//\t\t\t\t\t} \n//\t\t\t\t\tpBuff[(i * Mesh.VERTEX_SIZE) + Mesh.VERTEX_INDEX_Y] = mHeightOffsetCurrent[i];\n//\t\t\t\t}\n//\t\t\t}\n//\t\t\t\n//\t\t\tfloat getNormalizedSine(float x, float halfY, float maxX) {\t\n//\t\t\t double factor = (2 * Math.PI) / maxX;\n//\t\t\t return (float) ((Math.sin(x * factor) * halfY) + halfY);\n//\t\t\t}\n//\t\t\t\n//\t\t};\n\t\treturn pMesh;\n\t}","public void circulos() {\n pushMatrix();\n translate(width/2, height/2);\n rotate(-h);\n noFill();\n strokeWeight(5);\n stroke(255);\n ellipse(10, 10, 20, 20);\n popMatrix();\n\n h = h + 0.3f;\n }","public void zeichneQuadrate(){\n for (int i=0; i<10;i++)\n rect (50+i*25,50,25,25);\n }","private Node createVirtualWorldBoundsShape() {\n \t\tPoint3d lower = new Point3d();\n \t\tPoint3d upper = new Point3d();\n \t\tmyVirtualWorldBounds.getLower(lower);\n \t\tmyVirtualWorldBounds.getUpper(upper);\n \t\t\n \t\tdouble[] coordinates = { lower.x, lower.y, lower.z, upper.x, lower.y,\n \t\t\t\tlower.z, upper.x, lower.y, upper.z, lower.x, lower.y, upper.z,\n \t\t\t\tlower.x, upper.y, lower.z, upper.x, upper.y, lower.z, upper.x,\n \t\t\t\tupper.y, upper.z, lower.x, upper.y, upper.z };\n \t\t\n \t\tint[] coordinateIndices = { 0, 1, 1, 2, 2, 3, 3, 0, 4, 5, 5, 6, 6, 7,\n \t\t\t\t7, 4, 0, 4, 1, 5, 2, 6, 3, 7 };\n \t\t\n \t\tIndexedLineArray geometry = new IndexedLineArray(\n \t\t\t\tcoordinates.length / 3, IndexedLineArray.COORDINATES,\n \t\t\t\tcoordinateIndices.length);\n \t\t\n \t\tgeometry.setCoordinates(0, coordinates);\n \t\tgeometry.setCoordinateIndices(0, coordinateIndices);\n \t\t\n \t\treturn new Shape3D(geometry);\n \t}","public QuadMesh\n (boolean isBeingSplit,\n Matrix4f cubeMatrix, \n\t\tVector3f color,\n\t\tboolean inAtmosphere, \n\t\tVector3f meshOffset, \n\t\tboolean inFrustum, \n\t\tfloat arcLengthOverSize, \n\t\tVector3f center, \n\t\tfloat intensity, \n\t\tTexture2D Heightmap, \n\t\tString f ,\n\t\tQuadMesh p, \n\t\tVector3f v1, \n\t\tVector3f v2, \n\t\tVector3f v3, \n\t\tVector3f v4,\n\t\tfloat size,\n\t\tint x, \n\t\tint y, \n\t\tboolean hasChildren, \n\t\tArrayList children, \n\t\tBoundingSphere sphere, \n\t\tGeometry mesh, \n\t\tVector3f faceIndex, \n\t\tfloat centerOff,\n\t\tGeometry bsp)\t\n{\n\t\tfirst = v1;\n\t\tsecond = v2;\n\t\tthird = v3;\n\t\tfourth = v4;\n\t\twidth = size;\n\t\tindex1 = x;\n\t\tindex2 = y;\n\t\tthis.hasChildren = hasChildren;\n\t\tthis.children = children;\n\t\tparent = p;\n\t\tface = f;\n\t\tthis.sphere = sphere;\n\t\tthis.mesh = mesh;\n\t\tthis.faceIndex = faceIndex;\n\t\tthis.centerOff = centerOff;\n\t\tthis.Heightmap = Heightmap;\n\t\tthis.intensity = intensity;\n\t\tthis.arcLengthOverSize = arcLengthOverSize;\n\t\tthis.center = center;\n\t\tthis.inFrustum = inFrustum;\n\t\tthis.meshOffset = meshOffset;\n\t\tthis.inAtmosphere = inAtmosphere;\n\t\tthis.color = color;\n\t\tthis.cubeMatrix = cubeMatrix;\n\t\tthis.bsp = bsp;\n\n\t\n\t}","protected CylinderShade(String name) {\n\tsuper(name);\n }","private void createVertices(int iX, int iY, int iXO, int iYO, int num, int increment) {\n int y = iY;\n if (num == 0 && increment == 0) {\n BracketNode last = new BracketNode(\"\", iX, y - 20, iXO, 20);\n nodes.add(last);\n getChildren().addAll(new Line(iX, iY, iX + iXO, iY), last);\n last.setName(currentBracket.getBracket().get(location));\n bracketMap.put(last, location);\n nodeMap.put(location, last);\n } else {\n ArrayList aNodeList = new ArrayList<>();\n for (int i = 0; i < num; i++) {\n Point2D tl = new Point2D(iX, y);\n Point2D tr = new Point2D(iX + iXO, y);\n Point2D bl = new Point2D(iX, y + iYO);\n Point2D br = new Point2D(iX + iXO, y + iYO);\n BracketNode nTop = new BracketNode(\"\", iX, y - 20, iXO, 20);\n aNodeList.add(nTop);\n nodes.add(nTop);\n BracketNode nBottom = new BracketNode(\"\", iX, y + (iYO - 20), iXO, 20);\n aNodeList.add(nBottom);\n nodes.add(nBottom);\n Line top = new Line(tl.getX(), tl.getY(), tr.getX(), tr.getY());\n Line bottom = new Line(bl.getX(), bl.getY(), br.getX(), br.getY());\n Line right = new Line(tr.getX(), tr.getY(), br.getX(), br.getY());\n getChildren().addAll(top, bottom, right, nTop, nBottom);\n isTop = !isTop;\n y += increment;\n }\n ArrayList tmpHelp = helper(location, num);\n for (int j = 0; j < aNodeList.size(); j++) {\n //System.out.println(currentBracket.getBracket().get(tmpHelp.get(j)));\n aNodeList.get(j).setName(currentBracket.getBracket().get(tmpHelp.get(j)));\n bracketMap.put(aNodeList.get(j), tmpHelp.get(j));\n nodeMap.put(tmpHelp.get(j), aNodeList.get(j));\n //System.out.println(bracketMap.get(aNodeList.get(j)));\n }\n }\n\n }","public static void main(String[] args){\n Mesh3D box = Mesh3D.box(10, 20, 60);\n \n Line3D lineX = box.getLineX();\n Line3D lineY = box.getLineY();\n Line3D lineZ = box.getLineZ();\n lineX.show();\n lineY.show();\n lineZ.show();\n box.translateXYZ(100, 0.0, 0.0); \n box.show();\n Line3D line = new Line3D(); \n List intersects = new ArrayList();\n \n for(int p = 0; p < 100; p++){\n double r = 600;\n double theta = Math.toRadians(90.0);//Math.toRadians(Math.random()*180.0);\n double phi = Math.toRadians(Math.random()*360.0-180.0);\n line.set(0.0,0.0,0.0, \n Math.sin(theta)*Math.cos(phi)*r,\n Math.sin(theta)*Math.sin(phi)*r,\n Math.cos(theta)*r\n );\n intersects.clear();\n box.intersectionRay(line, intersects);\n System.out.println(\"theta/phi = \" + Math.toDegrees(theta) + \" \"\n + Math.toDegrees(phi) + \" intersects = \" + intersects.size());\n \n }\n }","public void texturedSphere(float r, PGraphics t) {\n int v1,v11,v2;\n r = (r + 240 ) * 0.33f;\n beginShape(TRIANGLE_STRIP);\n texture(t);\n float iu=(float)(t.width-1)/(sDetail);\n float iv=(float)(t.height-1)/(sDetail);\n float u=0,v=iv;\n for (int i = 0; i < sDetail; i++) {\n vertex(0, -r, 0,u,0);\n vertex(sphereX[i]*r, sphereY[i]*r, sphereZ[i]*r, u, v);\n u+=iu;\n }\n vertex(0, -r, 0,u,0);\n vertex(sphereX[0]*r, sphereY[0]*r, sphereZ[0]*r, u, v);\n endShape(); \n \n // Middle rings\n int voff = 0;\n for(int i = 2; i < sDetail; i++) {\n v1=v11=voff;\n voff += sDetail;\n v2=voff;\n u=0;\n beginShape(TRIANGLE_STRIP);\n texture(t);\n for (int j = 0; j < sDetail; j++) {\n vertex(sphereX[v1]*r, sphereY[v1]*r, sphereZ[v1++]*r, u, v);\n vertex(sphereX[v2]*r, sphereY[v2]*r, sphereZ[v2++]*r, u, v+iv);\n u+=iu;\n }\n \n // Close each ring\n v1=v11;\n v2=voff;\n vertex(sphereX[v1]*r, sphereY[v1]*r, sphereZ[v1]*r, u, v);\n vertex(sphereX[v2]*r, sphereY[v2]*r, sphereZ[v2]*r, u, v+iv);\n endShape();\n v+=iv;\n }\n u=0;\n \n // Add the northern cap\n beginShape(TRIANGLE_STRIP);\n texture(t);\n for (int i = 0; i < sDetail; i++) {\n v2 = voff + i;\n vertex(sphereX[v2]*r, sphereY[v2]*r, sphereZ[v2]*r, u, v);\n vertex(0, r, 0,u,v+iv); \n u+=iu;\n }\n vertex(sphereX[voff]*r, sphereY[voff]*r, sphereZ[voff]*r, u, v);\n endShape();\n \n}"],"string":"[\n \"public void makeCylinder (float radius, int radialDivisions, int heightDivisions)\\r\\n {\\r\\n \\t// Midpoint for top and bottom surfaces\\r\\n \\tPoint midTop = new Point( 0f, 0.5f, 0f);\\r\\n \\tPoint midBot = new Point( 0f, -0.5f, 0f );\\r\\n \\t\\r\\n \\tPoint upper[] = new Point[radialDivisions + 1];\\r\\n \\tPoint lower[] = new Point[radialDivisions + 1];\\r\\n \\t\\r\\n \\t// Calculate x and z coordinates using parametric equations\\r\\n \\t// Top circular surface\\r\\n \\tfor(int i = 0; i <= radialDivisions; i ++)\\r\\n \\t{\\r\\n \\t\\tupper[i] = new Point();\\r\\n \\t\\t\\r\\n \\t\\tupper[i].x = radius * (float)( Math.cos( Math.toRadians((360.0/radialDivisions ) * i ) ) );\\r\\n \\t\\tupper[i].z = radius * (float)( Math.sin( Math.toRadians((360.0/radialDivisions ) * i ) ) );\\r\\n \\t\\tupper[i].y = 0.5f;\\r\\n \\t\\t\\r\\n \\t}\\r\\n \\t\\r\\n \\t// Bottom circle\\r\\n \\tfor(int i = 0; i <= radialDivisions; i ++)\\r\\n \\t{\\r\\n \\t\\tlower[i] = new Point();\\r\\n \\t\\t\\r\\n \\t\\tlower[i].x = radius * (float)( Math.cos( ( Math.toRadians(360.0/radialDivisions * ( i ) ) ) ) );\\r\\n \\t\\tlower[i].z = radius * (float)( Math.sin( ( Math.toRadians(360.0/radialDivisions * ( i ) ) ) ) );\\r\\n \\t\\tlower[i].y = -0.5f;\\r\\n \\t\\t\\r\\n \\t}\\r\\n \\t\\r\\n \\t// Print both the top and bottom circular faces\\r\\n \\tfor( int i = 0; i < radialDivisions; i ++ )\\r\\n \\t{\\r\\n \\t\\tthis.addTriangle(midTop.x, midTop.y, midTop.z, upper[i + 1].x, upper[i + 1].y, upper[i + 1].z, upper[i].x, upper[i].y, upper[i].z);\\r\\n \\t}\\r\\n \\t\\r\\n \\tfor( int i = 0; i < radialDivisions; i ++ )\\r\\n \\t{\\r\\n \\t\\tthis.addTriangle(midBot.x, midBot.y, midBot.z, lower[i].x, lower[i].y, lower[i].z, lower[i + 1].x, lower[i + 1].y, lower[i + 1].z);\\r\\n \\t}\\r\\n \\t\\r\\n \\t\\r\\n \\t\\r\\n \\t// Curved Surface\\r\\n \\tfloat v = -0.5f;\\r\\n \\t\\r\\n \\tfloat vert[] = new float[heightDivisions + 1];\\r\\n \\t\\r\\n \\tfor( int i = 0; i <= heightDivisions; i++)\\r\\n \\t{\\r\\n \\t\\tvert[i] = v;\\r\\n \\t\\tv = v + (float)(1/(float)heightDivisions);\\r\\n \\t}\\r\\n \\t\\r\\n \\t// Display the curved surface faces\\r\\n \\tfor( int j = 0; j < heightDivisions; j ++ )\\r\\n \\t\\tfor(int k = 0; k < radialDivisions; k ++ )\\r\\n \\t\\t{\\r\\n \\t\\t\\tif( k == radialDivisions - 1 )\\r\\n \\t\\t\\t{\\r\\n \\t\\t\\t\\tPoint tempP1 = new Point(lower[k].x, vert[j], lower[k].z);\\r\\n \\t\\t\\t\\tPoint tempP2 = new Point(lower[0].x, vert[j], lower[0].z);\\r\\n \\t\\t\\t\\tPoint tempP3 = new Point(lower[0].x, vert[j + 1], lower[0].z);\\r\\n \\t\\t\\t\\tPoint tempP4 = new Point(lower[k].x, vert[j + 1], lower[k].z);\\r\\n \\t\\t\\t\\t\\r\\n \\t\\t\\t\\taddTriangle(tempP1.x, tempP1.y, tempP1.z, tempP4.x, tempP4.y, tempP4.z, tempP3.x, tempP3.y, tempP3.z );\\r\\n \\t\\t\\taddTriangle(tempP1.x, tempP1.y, tempP1.z, tempP3.x, tempP3.y, tempP3.z, tempP2.x, tempP2.y, tempP2.z);\\r\\n \\t\\t\\t}\\r\\n \\t\\t\\telse\\r\\n \\t\\t\\t{\\r\\n \\t\\t\\t\\tPoint tempP1 = new Point(lower[k].x, vert[j], lower[k].z);\\r\\n \\t\\t\\t\\tPoint tempP2 = new Point(lower[k + 1].x, vert[j], lower[k + 1].z);\\r\\n \\t\\t\\t\\tPoint tempP3 = new Point(lower[k + 1].x, vert[j + 1], lower[k + 1].z);\\r\\n \\t\\t\\t\\tPoint tempP4 = new Point(lower[k].x, vert[j + 1], lower[k].z);\\r\\n \\t\\t\\t\\t\\r\\n \\t\\t\\t\\taddTriangle(tempP1.x, tempP1.y, tempP1.z, tempP4.x, tempP4.y, tempP4.z, tempP3.x, tempP3.y, tempP3.z );\\r\\n \\t\\t\\taddTriangle(tempP1.x, tempP1.y, tempP1.z, tempP3.x, tempP3.y, tempP3.z, tempP2.x, tempP2.y, tempP2.z);\\r\\n \\t\\t\\t}\\r\\n \\t\\t}\\r\\n }\",\n \"public void DrawCylinder(float radius, float height, int nSegments ) \\n\\t{\\n\\t\\tGL11.glBegin(GL11.GL_TRIANGLES);\\n\\t\\tPoint4f point4f7 = new Point4f();\\n\\t\\tPoint4f point4f8 = new Point4f(0.0f, 0.0f, 1.0f, 0.0f);\\n\\t\\tfor(float i=0.0f; i < nSegments; i += 1.0f) {\\n\\t\\t\\t//First, the origin is located at the center of the circle below. First, draw the triangle above the side.\\n\\t\\t\\tfloat angle = (float)Math.PI * i * 2.0f / nSegments;\\n\\t\\t\\tfloat nextAngle = (float)Math.PI * (i + 1.0f) * 2.0f / nSegments;\\n\\t\\t\\tfloat x1 = (float)Math.sin((double)angle)*radius, y1 = (float)Math.cos((double)angle)*radius;\\n\\t\\t\\tfloat x2 = (float)Math.sin((double)nextAngle)*radius, y2 = (float)Math.cos((double)nextAngle)*radius;\\n\\n\\t\\t\\tPoint4f point4f1 = new Point4f(x1, y1, 0.0f, 0.0f);\\n\\t\\t\\tPoint4f point4f2 = new Point4f(x2, y2, 1.0f, 0.0f);\\n\\t\\t\\tPoint4f point4f3 = new Point4f(x1, y1, 1.0f, 0.0f);\\n\\t\\t\\tVector4f v = point4f2.MinusPoint(point4f1);\\n\\t\\t\\tVector4f w = point4f3.MinusPoint(point4f1);\\n\\t\\t\\tVector4f normal = v.cross(w).Normal();\\n//\\t\\t\\tGL11.glNormal3f( normal.x, normal.y, normal.z);\\n\\t\\t\\tGL11.glNormal3f( x1, y1, 0.0f);\\n\\t\\t\\tGL11.glVertex3f(x1, y1, 0.0f);\\n\\t\\t\\tGL11.glNormal3f( x2, y2, height);\\n GL11.glVertex3f(x2, y2, height);\\n GL11.glNormal3f( x1, y1, height);\\n GL11.glVertex3f(x1, y1, height);\\n \\n //Draw the triangle on top of the lid according to the triangle on top of the side.\\n Vector4f v2 = point4f2.MinusPoint(point4f8);\\n Vector4f w2 = point4f3.MinusPoint(point4f8);\\n Vector4f normal2 = v2.cross(w2).Normal();\\n GL11.glNormal3f( normal2.x, normal2.y, normal2.z);\\n GL11.glVertex3f(0.0f, 0.0f, height);\\n GL11.glVertex3f(x2, y2, height);\\n GL11.glVertex3f(x1, y1, height);\\n \\n //Draw the triangle below the sides.\\n Point4f point4f4 = new Point4f(x1, y1, 0.0f, 0.0f);\\n\\t\\t\\tPoint4f point4f5 = new Point4f(x2, y2, 0.0f, 0.0f);\\n\\t\\t\\tPoint4f point4f6 = new Point4f(x1, y1, 1.0f, 0.0f);\\n\\t\\t\\tVector4f v1 = point4f5.MinusPoint(point4f4);\\n\\t\\t\\tVector4f w1 = point4f6.MinusPoint(point4f4);\\n\\t\\t\\tVector4f normal1 = v1.cross(w1).Normal();\\n//\\t\\t\\tGL11.glNormal3f( normal1.x, normal1.y, normal1.z);\\n\\t\\t\\tGL11.glNormal3f( x1, y1, 0.0f);\\n\\t\\t\\tGL11.glVertex3f(x1, y1, 0.0f);\\n\\t\\t\\tGL11.glNormal3f( x2, y2, 0.0f);\\n GL11.glVertex3f(x2, y2, 0.0f);\\n GL11.glNormal3f( x2, y2, height);\\n GL11.glVertex3f(x2, y2, height);\\n \\n //Draw the triangle on the lower lid according to the triangle below the side.\\n Vector4f v3 = point4f4.MinusPoint(point4f7);\\n Vector4f w3 = point4f5.MinusPoint(point4f7);\\n Vector4f normal3 = v3.cross(w3).Normal();\\n GL11.glNormal3f( normal3.x, normal3.y, normal3.z);\\n GL11.glVertex3f(0.0f, 0.0f, 0.0f);\\n GL11.glVertex3f(x2, y2, 0.0f);\\n GL11.glVertex3f(x1, y1, 0.0f);\\n\\t\\t}\\n\\t\\tGL11.glEnd();\\n\\t}\",\n \"public void makeCone (float radius, int radialDivisions, int heightDivisions)\\r\\n {\\r\\n \\tPoint lower[][] = new Point[heightDivisions + 1][radialDivisions + 1];\\r\\n \\t\\r\\n \\tfloat rad[] = new float[heightDivisions + 1];\\r\\n \\tfloat vert = -0.5f;\\r\\n \\t\\r\\n \\t// Calculate radius for every subdivision along the height\\r\\n \\tfor(int i = 0; i < heightDivisions; i ++)\\r\\n \\t{\\r\\n \\t\\trad[i] = radius * ( 1.0f - ( 1f /(float)heightDivisions) * i );\\r\\n \\t}\\r\\n \\t\\r\\n \\t// Calculate curved surface vertices for every subdivision along the height\\r\\n \\tfor(int i = 0; i <= heightDivisions; i ++ )\\r\\n \\t{\\r\\n \\t\\tfor(int j = 0; j <= radialDivisions; j ++)\\r\\n \\t\\t{\\r\\n \\t\\t\\tlower[i][j] = new Point();\\r\\n \\t\\t\\tlower[i][j].x = rad[i] * (float)Math.cos(Math.toRadians ( (360.0f / (float)radialDivisions) * j ) );\\r\\n \\t\\t\\tlower[i][j].z = rad[i] * (float)Math.sin(Math.toRadians ( (360.0f / (float)radialDivisions) * j ) );\\r\\n \\t\\t\\tlower[i][j].y = vert;\\r\\n \\t\\t}\\r\\n \\t\\t// Update the y coordinate for next iteration\\r\\n \\t\\tvert += (1f / (float)heightDivisions);\\r\\n \\t}\\r\\n \\t\\r\\n \\tvert = -0.5f;\\r\\n \\t\\r\\n \\t// Print the bottom circular surface\\r\\n \\tfor(int i = 0; i <= radialDivisions - 1; i ++)\\r\\n \\t{\\r\\n \\t\\tthis.addTriangle(lower[0][i].x, vert, lower[0][i].z, 0f, vert, 0f, lower[0][i+1].x, vert, lower[0][i+1].z );\\r\\n \\t}\\r\\n \\t\\r\\n \\t// Print the curved surface\\r\\n \\tfor(int i = 0 ; i < heightDivisions; i++)\\r\\n \\t\\tfor(int j = 0 ; j < radialDivisions; j++)\\r\\n \\t\\t{\\r\\n \\t\\t\\tthis.addTriangle(lower[i][j].x, lower[i][j].y, lower[i][j].z, lower[i][j+1].x, lower[i][j+1].y, lower[i][j+1].z, lower[i+1][j+1].x, lower[i+1][j+1].y, lower[i+1][j+1].z);\\r\\n \\t\\t\\tthis.addTriangle(lower[i][j].x, lower[i][j].y, lower[i][j].z, lower[i+1][j+1].x, lower[i+1][j+1].y, lower[i+1][j+1].z, lower[i+1][j].x, lower[i+1][j].y, lower[i+1][j].z);\\r\\n \\t\\t\\t\\r\\n \\t\\t}\\r\\n }\",\n \"private void generateSphere() {\\n\\t\\tint segments = 14;\\n\\t\\tint rings = 15; // Use an odd number of rings of faces so that halfway up the sphere is the middle of a ring and not a loop of edges\\n\\t\\tverts = new Vector[segments * (rings - 1) + 2]; // There are rings + 1 rings of vertices, but the first and last of these are each a single vertex\\n\\t\\tfaces = new int[2 * segments * (rings - 1)][3]; // Apart from the first and last, each ring has segments number of square faces, so 2 * segments triangular faces. The first and last each have segments triangular faces\\n\\t\\tverts[0] = new Vector(3);\\n\\t\\tverts[0].setElement(1, -1); // The lowest point of the sphere\\n\\t\\tfor (int i = 0; i < segments; i++) {\\n\\t\\t\\tif (i == segments - 1) {\\n\\t\\t\\t\\tfaces[i] = new int[] {0, i + 1, 1}; // The last face involves the last vertex in the second ring and loops back to the first vertex in the second ring\\n\\t\\t\\t} else {\\n\\t\\t\\t\\tfaces[i] = new int[] {0, i + 1, i + 2}; // Triangles involving the lowest vertex and two consecutive vertices in the second ring of vertices\\n\\t\\t\\t}\\n\\t\\t}\\n\\t\\tdouble pitchIncrement = Math.PI / rings; // The increment in pitch (angle above horizontal) between rings of vertices\\n\\t\\tdouble pitch = pitchIncrement - Math.PI / 2; // The lowest point had a pitch of -pi/2\\n\\t\\tdouble headingIncrement = Math.PI * 2.0 / segments; // The increment in heading between segments\\n\\t\\tdouble heading = -Math.PI;\\n\\t\\tfor (int r = 0; r < rings - 1; r++) { // Last ring is a single point and must be treated separately\\n\\t\\t\\tdouble y = Math.sin(pitch); // The y co-ordinate for each vertex in this ring\\n\\t\\t\\tdouble modulus = Math.cos(pitch); // The radius of the circle which this ring lies on\\n\\t\\t\\tfor (int s = 0; s < segments; s++) {\\n\\t\\t\\t\\tdouble x = modulus * Math.cos(heading); // x co-ordinate for the next vertex\\n\\t\\t\\t\\tdouble z = modulus * Math.sin(heading); // z co-ordinate for the next vertex\\n\\t\\t\\t\\tverts[segments * r + s + 1] = new Vector(3);\\n\\t\\t\\t\\tverts[segments * r + s + 1].setElements(new double[] {x, y, z});\\n\\t\\t\\t\\theading += headingIncrement;\\n\\t\\t\\t}\\n\\t\\t\\t// Make faces between the vertices just added and the next ring of vertices to be added\\n\\t\\t\\tif (r != rings - 2) { // The second to last ring doesn't make faces with the next ring up in the same way because the last ring is a single vertex\\n\\t\\t\\t\\tfor (int i = 0; i < segments; i++) {\\n\\t\\t\\t\\t\\tif (i == segments - 1) { // The last two faces make use of the first vertex in the next ring by looping back to the start\\n\\t\\t\\t\\t\\t\\t// Two faces in the same plane\\n\\t\\t\\t\\t\\t\\tfaces[i * 2 + segments * (2 * r + 1)] = new int[] {segments * r + i + 1, (segments * r + i + 1) + segments, segments * r + 1 + segments};\\n\\t\\t\\t\\t\\t\\tfaces[i * 2 + segments * (2 * r + 1) + 1] = new int[] {segments * r + i + 1, segments * r + 1 + segments, segments * r + 1};\\n\\t\\t\\t\\t\\t} else {\\n\\t\\t\\t\\t\\t\\t// Two faces that are in the same plane and appear as a quadrilateral\\n\\t\\t\\t\\t\\t\\tfaces[i * 2 + segments * (2 * r + 1)] = new int[] {segments * r + i + 1, (segments * r + i + 1) + segments, (segments * r + i + 1) + segments + 1};\\n\\t\\t\\t\\t\\t\\tfaces[i * 2 + segments * (2 * r + 1) + 1] = new int[] {segments * r + i + 1, (segments * r + i + 1) + segments + 1, (segments * r + i + 1) + 1};\\n\\t\\t\\t\\t\\t}\\n\\t\\t\\t\\t}\\n\\t\\t\\t}\\n\\t\\t\\tpitch += pitchIncrement;\\n\\t\\t}\\n\\t\\tverts[verts.length - 1] = new Vector(3);\\n\\t\\tverts[verts.length - 1].setElement(1, 1); // The last and highest vertex\\n\\t\\tfor (int i = 0; i < segments; i++) {\\n\\t\\t\\tif (i == segments - 1) { // Last face completes the ring and includes the last vertex of the second to last ring\\n\\t\\t\\t\\tfaces[2 * segments + segments * (2 * rings - 5) + i] = new int[] {segments * (rings - 2) + 1 + i, segments * (rings - 1) + 1, segments * (rings - 2) + 1};\\n\\t\\t\\t} else { // Faces involving the last vertex and two consecutive vertices in the second to last ring\\n\\t\\t\\t\\tfaces[2 * segments + segments * (2 * rings - 5) + i] = new int[] {segments * (rings - 2) + 1 + i, segments * (rings - 1) + 1, segments * (rings - 2) + 1 + i + 1};\\n\\t\\t\\t}\\n\\t\\t}\\n\\t}\",\n \"private void generatePrism() {\\n\\t\\tdouble halfAltitude = Math.sin(Math.PI / 3); // The cross-section is an equilateral triangle with sides of length 2 units. The altitude is the height of the triangle with one edge horizontal\\n\\t\\tverts = new Vector[] {new Vector(3), new Vector(3), new Vector(3), new Vector(3), new Vector(3), new Vector(3)};\\n\\t\\tverts[0].setElements(new double[] {-1, -halfAltitude, -1});\\n\\t\\tverts[1].setElements(new double[] {0, halfAltitude, -1});\\n\\t\\tverts[2].setElements(new double[] {1, -halfAltitude, -1});\\n\\t\\t// Use the same triangle of vertices but offset by 2 units along the z-axis\\n\\t\\tverts[3].setElements(verts[0]);\\n\\t\\tverts[4].setElements(verts[1]);\\n\\t\\tverts[5].setElements(verts[2]);\\n\\t\\tverts[3].setElement(2, 1);\\n\\t\\tverts[4].setElement(2, 1);\\n\\t\\tverts[5].setElement(2, 1);\\n\\t\\t\\n\\t\\tfaces = new int[][] {{0, 1, 2}, {0, 5, 3}, {0, 2, 5}, {0, 3, 4}, {0, 4, 1}, {1, 4, 5}, {1, 5, 2}, {3, 5, 4}};\\n\\t}\",\n \"public void makeCube (int subdivisions)\\r\\n {\\r\\n \\tfloat horz[] = new float[subdivisions + 1];\\r\\n \\tfloat vert[] = new float[subdivisions + 1];\\r\\n \\t\\r\\n \\t\\r\\n \\t// Front face\\r\\n \\tPoint p1 = new Point(-0.5f, -0.5f, 0.5f);\\r\\n \\tPoint p2 = new Point(0.5f, -0.5f, 0.5f);\\r\\n \\tPoint p3 = new Point(0.5f, 0.5f, 0.5f);\\r\\n \\tPoint p4 = new Point(-0.5f, 0.5f, 0.5f);\\r\\n \\t\\r\\n \\tfloat h = p1.x;\\r\\n \\tfloat v = p1.y;\\r\\n \\t\\r\\n \\tfor( int i = 0; i <= subdivisions; i++ )\\r\\n \\t{\\r\\n \\t\\thorz[i] = h;\\r\\n \\t\\th = h + (float)(1/(float)subdivisions);\\r\\n \\t}\\r\\n \\t\\r\\n \\tfor( int i = 0; i <= subdivisions; i++)\\r\\n \\t{\\r\\n \\t\\tvert[i] = v;\\r\\n \\t\\tv = v + (float)(1/(float)subdivisions);\\r\\n \\t}\\r\\n \\t\\r\\n \\tfor( int j = 0; j < vert.length - 1; j ++)\\r\\n \\t\\tfor( int k = 0; k < horz.length - 1; k ++)\\r\\n \\t\\t{\\r\\n \\t\\t\\tPoint tempP1 = new Point(horz[k], vert[j], 0.5f);\\r\\n \\t\\t\\tPoint tempP2 = new Point(horz[k + 1], vert[j], 0.5f);\\r\\n \\t\\t\\tPoint tempP3 = new Point(horz[k + 1], vert[j + 1], 0.5f);\\r\\n \\t\\t\\tPoint tempP4 = new Point(horz[k], vert[j + 1], 0.5f);\\r\\n \\t\\t\\t\\r\\n \\t\\t\\taddTriangle(tempP1.x, tempP1.y, tempP1.z, tempP3.x, tempP3.y, tempP3.z, tempP4.x, tempP4.y, tempP4.z);\\r\\n \\t\\t\\taddTriangle(tempP1.x, tempP1.y, tempP1.z, tempP2.x, tempP2.y, tempP2.z, tempP3.x, tempP3.y, tempP3.z);\\r\\n \\t\\t\\t\\r\\n \\t\\t}\\r\\n \\t\\r\\n \\t// Back face\\r\\n \\tp1.y = p1.z = -0.5f;\\r\\n \\tp1.x = 0.5f;\\r\\n \\tp2.x = p2.y = p2.z = -0.5f;\\r\\n \\tp3.x = p3.z = -0.5f;\\r\\n \\tp3.y = 0.5f;\\r\\n \\tp4.x = p4.y = 0.5f;\\r\\n \\tp4.z = -0.5f;\\r\\n \\t\\r\\n \\th = p1.x;\\r\\n \\tv = p1.y;\\r\\n \\t\\r\\n \\t\\r\\n \\tfor( int i = 0; i <= subdivisions; i++ )\\r\\n \\t{\\r\\n \\t\\thorz[i] = h;\\r\\n \\t\\th = h - (float)(1/(float)subdivisions);\\r\\n \\t}\\r\\n \\t\\r\\n \\tfor( int i = 0; i <= subdivisions; i++)\\r\\n \\t{\\r\\n \\t\\tvert[i] = v;\\r\\n \\t\\tv = v + (float)(1/(float)subdivisions);\\r\\n \\t}\\r\\n \\t\\r\\n \\tfor( int j = 0; j < vert.length - 1; j ++)\\r\\n \\t\\tfor( int k = 0; k < horz.length - 1; k ++)\\r\\n \\t\\t{\\r\\n \\t\\t\\tPoint tempP1 = new Point(horz[k], vert[j], -0.5f);\\r\\n \\t\\t\\tPoint tempP2 = new Point(horz[k + 1], vert[j], -0.5f);\\r\\n \\t\\t\\tPoint tempP3 = new Point(horz[k + 1], vert[j + 1], -0.5f);\\r\\n \\t\\t\\tPoint tempP4 = new Point(horz[k], vert[j + 1], -0.5f);\\r\\n \\t\\t\\t\\r\\n \\t\\t\\taddTriangle(tempP1.x, tempP1.y, tempP1.z, tempP3.x, tempP3.y, tempP3.z, tempP4.x, tempP4.y, tempP4.z);\\r\\n \\t\\t\\taddTriangle(tempP1.x, tempP1.y, tempP1.z, tempP2.x, tempP2.y, tempP2.z, tempP3.x, tempP3.y, tempP3.z);\\r\\n \\t\\t\\t\\r\\n \\t\\t}\\r\\n \\t\\r\\n \\t// Left face\\r\\n \\tp1.x = p1.y = p1.z = -0.5f;\\r\\n \\tp2.x = p2.y = -0.5f;\\r\\n \\tp2.z = 0.5f;\\r\\n \\tp3.x = -0.5f;\\r\\n \\tp3.y = p3.z = 0.5f;\\r\\n \\tp4.y = 0.5f;\\r\\n \\tp4.x = p4.z = -0.5f;\\r\\n \\t\\r\\n \\th = p1.z;\\r\\n \\tv = p1.y;\\r\\n \\t\\r\\n \\t\\r\\n \\tfor( int i = 0; i <= subdivisions; i++ )\\r\\n \\t{\\r\\n \\t\\thorz[i] = h;\\r\\n \\t\\th = h + (float)(1/(float)subdivisions);\\r\\n \\t}\\r\\n \\t\\r\\n \\tfor( int i = 0; i <= subdivisions; i++)\\r\\n \\t{\\r\\n \\t\\tvert[i] = v;\\r\\n \\t\\tv = v + (float)(1/(float)subdivisions);\\r\\n \\t}\\r\\n \\t\\r\\n \\tfor( int j = 0; j < vert.length - 1; j ++)\\r\\n \\t\\tfor( int k = 0; k < horz.length - 1; k ++)\\r\\n \\t\\t{\\r\\n \\t\\t\\tPoint tempP1 = new Point(-0.5f, vert[j], horz[k]);\\r\\n \\t\\t\\tPoint tempP2 = new Point(-0.5f, vert[j], horz[k + 1]);\\r\\n \\t\\t\\tPoint tempP3 = new Point(-0.5f, vert[j + 1], horz[k + 1]);\\r\\n \\t\\t\\tPoint tempP4 = new Point(-0.5f, vert[j + 1], horz[k]);\\r\\n \\t\\t\\t\\r\\n \\t\\t\\taddTriangle(tempP1.x, tempP1.y, tempP1.z, tempP3.x, tempP3.y, tempP3.z, tempP4.x, tempP4.y, tempP4.z);\\r\\n \\t\\t\\taddTriangle(tempP1.x, tempP1.y, tempP1.z, tempP2.x, tempP2.y, tempP2.z, tempP3.x, tempP3.y, tempP3.z);\\r\\n \\t\\t\\t\\r\\n \\t\\t}\\r\\n \\t\\r\\n \\t// Right face\\r\\n \\tp1.x = p1.z = 0.5f;\\r\\n \\tp1.y = -0.5f;\\r\\n \\tp2.y = p2.z = -0.5f;\\r\\n \\tp2.x = 0.5f;\\r\\n \\tp3.x = p3.y = 0.5f;\\r\\n \\tp3.z = -0.5f;\\r\\n \\tp4.x = p4.y = p4.z = 0.5f;\\r\\n \\t\\r\\n \\t\\r\\n \\th = p1.z;\\r\\n \\tv = p1.y;\\r\\n \\t\\r\\n \\t\\r\\n \\tfor( int i = 0; i <= subdivisions; i++ )\\r\\n \\t{\\r\\n \\t\\thorz[i] = h;\\r\\n \\t\\th = h - (float)(1/(float)subdivisions);\\r\\n \\t}\\r\\n \\t\\r\\n \\tfor( int i = 0; i <= subdivisions; i++)\\r\\n \\t{\\r\\n \\t\\tvert[i] = v;\\r\\n \\t\\tv = v + (float)(1/(float)subdivisions);\\r\\n \\t}\\r\\n \\t\\r\\n \\tfor( int j = 0; j < vert.length - 1; j ++)\\r\\n \\t\\tfor( int k = 0; k < horz.length - 1; k ++)\\r\\n \\t\\t{\\r\\n \\t\\t\\tPoint tempP1 = new Point(0.5f, vert[j], horz[k]);\\r\\n \\t\\t\\tPoint tempP2 = new Point(0.5f, vert[j], horz[k + 1]);\\r\\n \\t\\t\\tPoint tempP3 = new Point(0.5f, vert[j + 1], horz[k + 1]);\\r\\n \\t\\t\\tPoint tempP4 = new Point(0.5f, vert[j + 1], horz[k]);\\r\\n \\t\\t\\t\\r\\n \\t\\t\\taddTriangle(tempP1.x, tempP1.y, tempP1.z, tempP3.x, tempP3.y, tempP3.z, tempP4.x, tempP4.y, tempP4.z);\\r\\n \\t\\t\\taddTriangle(tempP1.x, tempP1.y, tempP1.z, tempP2.x, tempP2.y, tempP2.z, tempP3.x, tempP3.y, tempP3.z);\\r\\n \\t\\t\\t\\r\\n \\t\\t}\\r\\n \\t\\r\\n \\t// Top face\\r\\n \\tp1.x = -0.5f;\\r\\n \\tp1.y = p1.z = 0.5f;\\r\\n \\tp2.x = p2.y = p2.z = 0.5f;\\r\\n \\tp3.x = p3.y = 0.5f;\\r\\n \\tp3.z = -0.5f;\\r\\n \\tp4.x = p4.z = -0.5f;\\r\\n \\tp4.y = 0.5f;\\r\\n \\t\\r\\n \\t\\r\\n \\th = p1.x;\\r\\n \\tv = p1.z;\\r\\n \\t\\r\\n \\t\\r\\n \\tfor( int i = 0; i <= subdivisions; i++ )\\r\\n \\t{\\r\\n \\t\\thorz[i] = h;\\r\\n \\t\\th = h + (float)(1/(float)subdivisions);\\r\\n \\t}\\r\\n \\t\\r\\n \\tfor( int i = 0; i <= subdivisions; i++)\\r\\n \\t{\\r\\n \\t\\tvert[i] = v;\\r\\n \\t\\tv = v - (float)(1/(float)subdivisions);\\r\\n \\t}\\r\\n \\t\\r\\n \\tfor( int j = 0; j < vert.length - 1; j ++)\\r\\n \\t\\tfor( int k = 0; k < horz.length - 1; k ++)\\r\\n \\t\\t{\\r\\n \\t\\t\\tPoint tempP1 = new Point(horz[k], 0.5f, vert[j]);\\r\\n \\t\\t\\tPoint tempP2 = new Point(horz[k + 1], 0.5f, vert[j]);\\r\\n \\t\\t\\tPoint tempP3 = new Point(horz[k + 1], 0.5f, vert[j + 1]);\\r\\n \\t\\t\\tPoint tempP4 = new Point(horz[k], 0.5f, vert[j + 1]);\\r\\n \\t\\t\\t\\r\\n \\t\\t\\taddTriangle(tempP1.x, tempP1.y, tempP1.z, tempP3.x, tempP3.y, tempP3.z, tempP4.x, tempP4.y, tempP4.z);\\r\\n \\t\\t\\taddTriangle(tempP1.x, tempP1.y, tempP1.z, tempP2.x, tempP2.y, tempP2.z, tempP3.x, tempP3.y, tempP3.z);\\r\\n \\t\\t\\t\\r\\n \\t\\t}\\r\\n \\t\\r\\n \\t// Bottom face\\r\\n \\tp1.x = p1.y = p1.z = -0.5f;\\r\\n \\tp2.y = p2.z = 0.5f;\\r\\n \\tp2.x = 0.5f;\\r\\n \\tp3.x = p3.z = 0.5f;\\r\\n \\tp3.y = -0.5f;\\r\\n \\tp4.x = p4.y = -0.5f;\\r\\n \\tp4.z = 0.5f;\\r\\n \\t\\r\\n \\t\\r\\n \\th = p1.x;\\r\\n \\tv = p1.z;\\r\\n \\t\\r\\n \\t\\r\\n \\tfor( int i = 0; i <= subdivisions; i++ )\\r\\n \\t{\\r\\n \\t\\thorz[i] = h;\\r\\n \\t\\th = h + (float)(1/(float)subdivisions);\\r\\n \\t}\\r\\n \\t\\r\\n \\tfor( int i = 0; i <= subdivisions; i++)\\r\\n \\t{\\r\\n \\t\\tvert[i] = v;\\r\\n \\t\\tv = v + (float)(1/(float)subdivisions);\\r\\n \\t}\\r\\n \\t\\r\\n \\tfor( int j = 0; j < vert.length - 1; j ++)\\r\\n \\t\\tfor( int k = 0; k < horz.length - 1; k ++)\\r\\n \\t\\t{\\r\\n \\t\\t\\tPoint tempP1 = new Point(horz[k], -0.5f, vert[j]);\\r\\n \\t\\t\\tPoint tempP2 = new Point(horz[k + 1], -0.5f, vert[j]);\\r\\n \\t\\t\\tPoint tempP3 = new Point(horz[k + 1], -0.5f, vert[j + 1]);\\r\\n \\t\\t\\tPoint tempP4 = new Point(horz[k], -0.5f, vert[j + 1]);\\r\\n \\t\\t\\t\\r\\n \\t\\t\\taddTriangle(tempP1.x, tempP1.y, tempP1.z, tempP3.x, tempP3.y, tempP3.z, tempP4.x, tempP4.y, tempP4.z);\\r\\n \\t\\t\\taddTriangle(tempP1.x, tempP1.y, tempP1.z, tempP2.x, tempP2.y, tempP2.z, tempP3.x, tempP3.y, tempP3.z);\\r\\n \\t\\t\\t\\r\\n \\t\\t}\\r\\n \\t\\r\\n }\",\n \"public Prism(int numSides, double radius, double height) {\\n Vector3d toTop = new Vector3d(0.0, 0.0, height);\\n double centralAngle = 2.0 * Math.PI / numSides;\\n\\n Face bottomFace = new Face(numSides);\\n Face topFace = new Face(numSides);\\n int vertexIndex = 0;\\n for (int i = 0; i < numSides; i++) {\\n double totalAngle = centralAngle * i;\\n double x = radius * Math.cos(totalAngle);\\n double y = radius * Math.sin(totalAngle);\\n Vector3d bottomVertex = new Vector3d(x, y, -height / 2.0);\\n\\n Vector3d topVertex = new Vector3d();\\n topVertex.add(bottomVertex, toTop);\\n\\n addVertexPositions(bottomVertex, topVertex);\\n\\n bottomFace.setVertexIndex(numSides - i - 1, vertexIndex);\\n topFace.setVertexIndex(i, vertexIndex + 1);\\n\\n Face quad = new Face(4);\\n int nextBottom = (vertexIndex + 2) % (2 * numSides);\\n int nextTop = nextBottom + 1;\\n quad.setAllVertexIndices(vertexIndex, nextBottom, nextTop,\\n vertexIndex + 1);\\n\\n addFace(quad);\\n\\n vertexIndex += 2;\\n }\\n\\n addFaces(bottomFace, topFace);\\n\\n setVertexNormalsToFaceNormals();\\n }\",\n \"public static DeformableMesh3D createRectangleMesh(double width, double height, double depth, double segment_size){\\n ArrayList pts = new ArrayList();\\n ArrayList connections = new ArrayList();\\n ArrayList triangles = new ArrayList();\\n //For the complete length there will be n+1 nodes\\n int nx = (int)(width/segment_size + 0.5) + 1;\\n int ny = (int)(height/segment_size+0.5) + 1;\\n int nz = (int)(depth/segment_size+0.5) + 1;\\n double actual_w = (nx-1)*segment_size;\\n double actual_h = (ny-1)*segment_size;\\n double actual_z = (nz-1)*segment_size;\\n\\n int dex;\\n\\n //top face x-y @ actual_z/2\\n int top_starting_dex = pts.size();\\n for(int i = 0; i0){\\n connections.add(new int[]{\\n dex,\\n dex - ny\\n });\\n }\\n\\n if(j>0){\\n connections.add(new int[]{\\n dex,\\n dex-1\\n });\\n }\\n }\\n }\\n\\n for(int i = 1; i0){\\n connections.add(new int[]{\\n dex,\\n dex - ny\\n });\\n }\\n\\n if(j>0){\\n connections.add(new int[]{\\n dex,\\n dex - 1\\n });\\n }\\n\\n\\n }\\n }\\n //bottom face\\n for(int i = 1; i0){\\n //previous row\\n connections.add(new int[]{\\n dex,\\n dex - (nz-2)\\n });\\n }\\n\\n if(j>1){\\n //previous column\\n connections.add(new int[]{\\n dex,\\n dex - 1\\n });\\n }\\n }\\n }\\n\\n\\n //left face connections\\n for(int i = 0; i0){\\n //previous row\\n connections.add(new int[]{\\n dex,\\n dex - (nz-2)\\n });\\n }\\n\\n if(j>1){\\n //previous column\\n connections.add(new int[]{\\n dex,\\n dex - 1\\n });\\n }\\n }\\n }\\n\\n for(int i = 0; i1){\\n connections.add(new int[]{\\n dex,\\n dex - (nz-2)\\n });\\n }\\n\\n if(j>1){\\n connections.add(new int[]{\\n dex,\\n dex - 1\\n });\\n }\\n\\n\\n }\\n }\\n\\n //connect to top and bottom.\\n for(int i = 1; i1){\\n connections.add(new int[]{\\n dex,\\n dex - (nz-2)\\n });\\n }\\n\\n if(j>1){\\n connections.add(new int[]{\\n dex,\\n dex - 1\\n });\\n }\\n\\n\\n }\\n }\\n\\n\\n //connect to top and bottom.\\n for(int i = 1; i> findIntersections(Ray myRay) {\\n public List FindIntersections(Ray myRay) {\\n\\n List geometryListMap = new ArrayList<>();\\n List listOfIntersections = new ArrayList();\\n\\n // the bottom base of the cylinder\\n Plane plane1 = new Plane(orientation.getPOO(), orientation.getDirection());\\n\\n // the top base of the cylinder\\n Plane plane2 = new Plane(top, orientation.getDirection());\\n\\n List temp1 = plane1.FindIntersections(myRay);\\n\\n List temp2 = plane2.FindIntersections(myRay);\\n\\n // removing all points that beyond the radius\\n if (temp1 != null)\\n for (Point3D p1 : temp1) {\\n if (new Vector(Point3D.substract(orientation.getPOO(), p1)).length() <= _radius && p1 != null)\\n listOfIntersections.add(p1);\\n\\n }\\n\\n if (temp2 != null)\\n for (Point3D p2 : temp2) {\\n if (new Vector(Point3D.substract(orientation.getPOO(), p2)).length() <= _radius && p2 != null)\\n listOfIntersections.add(p2);\\n\\n }\\n\\n // using the infinity cylinder to find all the intersections in the body of the limited cylinder\\n geometryListMap = super.FindIntersections(myRay);\\n\\n for (Point3D p : geometryListMap) {\\n if (isOnCylinder(p))\\n listOfIntersections.add(p);\\n\\n }\\n if (listOfIntersections.isEmpty())\\n return null;\\n //geometryListMap.put(this, listOfIntersections);\\n return geometryListMap;\\n }\",\n \"private void generateCube() {\\n\\t\\tverts = new Vector[] {new Vector(3), new Vector(3), new Vector(3), new Vector(3), new Vector(3), new Vector(3), new Vector(3), new Vector(3)};\\n\\t\\tverts[0].setElement(0, -1);\\n\\t\\tverts[0].setElement(1, -1);\\n\\t\\tverts[0].setElement(2, -1);\\n\\t\\t\\n\\t\\tverts[1].setElement(0, 1);\\n\\t\\tverts[1].setElement(1, -1);\\n\\t\\tverts[1].setElement(2, -1);\\n\\t\\t\\n\\t\\tverts[2].setElement(0, -1);\\n\\t\\tverts[2].setElement(1, -1);\\n\\t\\tverts[2].setElement(2, 1);\\n\\t\\t\\n\\t\\tverts[3].setElement(0, 1);\\n\\t\\tverts[3].setElement(1, -1);\\n\\t\\tverts[3].setElement(2, 1);\\n\\t\\t\\n\\t\\tverts[4].setElement(0, -1);\\n\\t\\tverts[4].setElement(1, 1);\\n\\t\\tverts[4].setElement(2, -1);\\n\\t\\t\\n\\t\\tverts[5].setElement(0, 1);\\n\\t\\tverts[5].setElement(1, 1);\\n\\t\\tverts[5].setElement(2, -1);\\n\\t\\t\\n\\t\\tverts[6].setElement(0, -1);\\n\\t\\tverts[6].setElement(1, 1);\\n\\t\\tverts[6].setElement(2, 1);\\n\\t\\t\\n\\t\\tverts[7].setElement(0, 1);\\n\\t\\tverts[7].setElement(1, 1);\\n\\t\\tverts[7].setElement(2, 1);\\n\\t\\t\\n\\t\\tfaces = new int[][] {{0, 3, 2}, {0, 1, 3}, {0, 4, 5}, {0, 5, 1}, {0, 2, 6}, {0, 6, 4}, {2, 7, 6}, {2, 3, 7}, {3, 1, 5}, {3, 5, 7}, {4, 7, 5}, {4, 6, 7}}; // List the vertices of each face by index in verts. Vertices must be listed in clockwise order from outside of the shape so that the faces pointing away from the camera can be culled or shaded differently\\n\\t}\",\n \"public void makeCone(float radius, int radialDivisions, int heightDivisions) {\\n\\t\\t// System.out.println(\\\"ram\\\");\\n\\t\\tif (radialDivisions < 3)\\n\\t\\t\\tradialDivisions = 3;\\n\\n\\t\\tif (heightDivisions < 1)\\n\\t\\t\\theightDivisions = 1;\\n\\n\\t\\tif (heightDivisions > 65)\\n\\t\\t\\theightDivisions = 65;\\n\\n\\t\\tif (radialDivisions > 65)\\n\\t\\t\\tradialDivisions = 65;\\n\\t//\\tSystem.out.println(radialDivisions + \\\" \\\" + heightDivisions);\\n\\t\\t// coordinates for the triangle formation\\n\\t\\tfloat x1 = 0;\\n\\t\\tfloat y1 = 0;\\n\\t\\tfloat z1 = 0;\\n\\t\\tfloat x2 = 0;\\n\\t\\tfloat y2 = 0;\\n\\t\\tfloat z2 = 0;\\n\\t\\tfloat x3 = 0;\\n\\t\\tfloat y3 = 0;\\n\\t\\tfloat z3 = 0;\\n\\t\\tfloat theta = (float) (2 * Math.PI / radialDivisions);\\n\\t\\tfloat refy = -0.5f;\\n\\t\\tfloat nexty = 1f / heightDivisions;\\n\\t\\tfor (int rD = 0; rD < radialDivisions; rD++) {\\n\\t\\t\\t//defining coordinates of first point\\n\\t\\t\\tx1 = 0f;\\n\\t\\t\\ty1 = refy;\\n\\t\\t\\tz1 = 0f;\\n\\t\\t\\t//defining coordinates of second point\\n\\t\\t\\tx2 = (float) (radius * Math.cos(theta * rD));\\n\\t\\t\\ty2 = y1;\\n\\t\\t\\tz2 = -(float) (radius * Math.sin(theta * rD));\\n\\t\\t\\t//defining coordinates of third point\\n\\t\\t\\tx3 = (float) (radius * Math.cos(theta * (rD + 1)));\\n\\t\\t\\ty3 = y1;\\n\\t\\t\\tz3 = -(float) (radius * Math.sin(theta * (rD + 1)));\\n\\n\\t\\t\\t// tessellation for circle\\n\\t\\t\\taddTriangle(x1, y1, z1, 0.0f, 0.0f, x2, y2, z2, 0.0f, 0.0f, x3, y3, z3, 0.0f, 0.0f);\\n\\n\\t\\t\\t// tessellation for covering\\n\\t\\t\\tfor (int hD = 0; hD < heightDivisions; hD++) {\\n\\t\\t\\t\\t//updating coordinates of first point\\n\\t\\t\\t\\tx1 = (float) ((radius - (radius * hD / heightDivisions)) * Math\\n\\t\\t\\t\\t\\t\\t.cos(theta * (rD + 1)));\\n\\t\\t\\t\\ty1 = refy + (nexty * hD);\\n\\t\\t\\t\\tz1 = -(float) ((radius - (radius * hD / heightDivisions)) * Math\\n\\t\\t\\t\\t\\t\\t.sin(theta * (rD + 1)));\\n\\t\\t\\t\\t//updating coordinates of first point\\n\\t\\t\\t\\tx2 = (float) ((radius - (radius * hD / heightDivisions)) * Math\\n\\t\\t\\t\\t\\t\\t.cos(theta * rD));\\n\\t\\t\\t\\ty2 = refy + (nexty * hD);\\n\\t\\t\\t\\tz2 = -(float) ((radius - (radius * hD / heightDivisions)) * Math\\n\\t\\t\\t\\t\\t\\t.sin(theta * rD));\\n\\t\\t\\t\\t//updating coordinates of first point\\n\\t\\t\\t\\tx3 = (float) ((radius - (radius * (hD + 1) / heightDivisions)) * Math\\n\\t\\t\\t\\t\\t\\t.cos(theta * rD));\\n\\t\\t\\t\\ty3 = refy + (nexty * (hD + 1));\\n\\t\\t\\t\\tz3 = -(float) ((radius - (radius * (hD + 1) / heightDivisions)) * Math\\n\\t\\t\\t\\t\\t\\t.sin(theta * rD));\\n\\n\\t\\t\\t\\taddTriangle(x1, y1, z1, 0.0f, 0.0f, x2, y2, z2, 0.0f, 0.0f, x3, y3, z3, 0.0f, 0.0f);\\n\\t\\t\\t\\t//updating coordinates of first point\\n\\t\\t\\t\\tx1 = (float) ((radius - (radius * (hD + 1) / heightDivisions)) * Math\\n\\t\\t\\t\\t\\t\\t.cos(theta * (rD + 1)));\\n\\t\\t\\t\\ty1 = refy + (nexty * (hD + 1));\\n\\t\\t\\t\\tz1 = -(float) ((radius - (radius * (hD + 1) / heightDivisions)) * Math\\n\\t\\t\\t\\t\\t\\t.sin(theta * (rD + 1)));\\n\\t\\t\\t\\t//updating coordinates of first point\\n\\t\\t\\t\\tx2 = (float) ((radius - (radius * hD / heightDivisions)) * Math\\n\\t\\t\\t\\t\\t\\t.cos(theta * (rD + 1)));\\n\\t\\t\\t\\ty2 = refy + (nexty * hD);\\n\\t\\t\\t\\tz2 = -(float) ((radius - (radius * hD / heightDivisions)) * Math\\n\\t\\t\\t\\t\\t\\t.sin(theta * (rD + 1)));\\n\\n\\t\\t\\t\\taddTriangle(x1, y1, z1, 0.0f, 0.0f, x2, y2, z2, 0.0f, 0.0f, x3, y3, z3, 0.0f, 0.0f);\\n\\n\\t\\t\\t}\\n\\n\\t\\t}\\n\\n\\t}\",\n \"public Cylinder(double height, double radius) {\\n\\t\\tsuper();\\n\\t\\tthis.height = height;\\n\\t\\tthis.radius = radius;\\n\\t\\tthis.center = false;\\n\\t}\",\n \"public void calculate() {\\n\\t\\t\\n\\t\\tHashMap vertices = triangulation.getVertices();\\n\\t\\tHashMap faces = triangulation.getFaces();\\n\\n\\t\\tHashMap chords = new HashMap();\\n\\t\\tList onOuterCircle = new LinkedList();\\n\\t\\tList outerCircle = new LinkedList();\\n\\n\\t\\tfor (Vertex v : vertices.values()) {\\n\\t\\t\\tchords.put(v.getId(), 0);\\n\\t\\t\\tchildren.put(v.getId(), new LinkedList());\\n\\t\\t}\\n\\n\\t\\t// determine outer face (randomly, use the first face)\\n\\t\\tFace outerFace = null;\\n\\t\\tfor (Face f : faces.values()) {\\n\\t\\t\\touterFace = f;\\n\\t\\t\\tbreak;\\n\\t\\t}\\n\\t\\tif (outerFace == null) {\\n\\t\\t\\t// there are no faces at all in the embedding\\n\\t\\t\\treturn;\\n\\t\\t}\\n\\n\\t\\tEdge e = outerFace.getIncidentEdge();\\n\\t\\tvertexOrder[1] = e.getSource();\\n\\t\\tvertexOrder[0] = e.getTarget();\\n\\t\\tonOuterCircle.add(e.getTarget());\\n\\t\\tonOuterCircle.add(e.getNext().getTarget());\\n\\t\\tonOuterCircle.add(e.getSource());\\n\\t\\touterCircle.add(e.getNext().getNext().getTwin());\\n\\t\\touterCircle.add(e.getNext().getTwin());\\n\\t\\t\\n\\t\\t//System.out.println(\\\"outerCircle 0 \\\" + outerCircle.get(0).getId() + \\\" - source: \\\" + outerCircle.get(0).getSource().getId() + \\\" - target: \\\" + outerCircle.get(0).getTarget().getId());\\n\\t\\t//System.out.println(\\\"outerCircle 1 \\\" + outerCircle.get(1).getId() + \\\" - source: \\\" + outerCircle.get(1).getSource().getId() + \\\" - target: \\\" + outerCircle.get(1).getTarget().getId());\\n\\t\\t\\n\\n\\t\\tfor (int k=vertexOrder.length-1; k>1; k--) {\\n\\t\\t\\t//System.out.println(\\\"k: \\\" + k + \\\" - outerCircle size: \\\" + outerCircle.size());\\n\\t\\t\\t// chose v != v_0,v_1 such that v on outer face, not considered yet and chords(v)=0\\n\\t\\t\\tVertex nextVertex = null;\\n\\t\\t\\tint nextVertexId = -1;\\n\\t\\t\\tfor (int i=0; i childrenNextVertex = children.get(nextVertexId);\\n\\t\\t\\t\\n\\t\\t\\t// update edges of outer circle\\n\\t\\t\\tint index = 0;\\n\\t\\t\\t\\n\\t\\t\\twhile (outerCircle.get(index).getTarget().getId() != nextVertexId) {\\n\\t\\t\\t\\tindex++;\\n\\t\\t\\t}\\n\\t\\t\\tEdge outofNextVertex = outerCircle.remove(index+1);\\n\\t\\t\\t\\n\\t\\t\\t\\n\\t\\t\\t//System.out.println(\\\"outOfNextVertex \\\" + outofNextVertex.getId() + \\\" - source: \\\" + outofNextVertex.getSource().getId() + \\\" - target: \\\" + outofNextVertex.getTarget().getId());\\n\\t\\t\\tEdge intoNextVertex = outerCircle.remove(index);\\n\\t\\t\\t//System.out.println(\\\"intoNextVertex \\\" + intoNextVertex.getId() + \\\" - source: \\\" + intoNextVertex.getSource().getId() + \\\" - target: \\\" + intoNextVertex.getTarget().getId());\\n\\t\\t\\tEdge current = intoNextVertex.getNext();\\n\\t\\t\\t//System.out.println(\\\"current \\\" + current.getId() + \\\" - source: \\\" + current.getSource().getId() + \\\" - target: \\\" + current.getTarget().getId());\\n\\t\\t\\t\\n\\t\\t\\tint endIndex = index;\\n\\t\\t\\t\\n\\t\\t\\twhile (current.getId() != outofNextVertex.getId()) {\\n\\t\\t\\t\\tEdge onCircle = current.getNext().getTwin();\\n\\t\\t\\t\\touterCircle.add(endIndex, onCircle);\\n\\t\\t\\t\\t\\n\\t\\t\\t\\tchildrenNextVertex.add(0, onCircle.getSource().getId());\\n\\t\\t\\t\\t\\n\\t\\t\\t\\tendIndex++;\\n\\t\\t\\t\\tcurrent = current.getTwin().getNext();\\n\\t\\t\\t\\tonOuterCircle.add(onCircle.getTarget());\\n\\t\\t\\t}\\n\\t\\t\\t\\n\\t\\t\\tEdge lastEdge = outofNextVertex.getNext().getTwin();\\n\\t\\t\\touterCircle.add(endIndex, lastEdge);\\n\\t\\t\\t\\n\\t\\t\\tchildrenNextVertex.add(0, lastEdge.getSource().getId());\\n\\t\\t\\tchildrenNextVertex.add(0, lastEdge.getTarget().getId());\\n\\n\\t\\t\\t// update chords\\n\\t\\t\\tfor (Vertex v : onOuterCircle) {\\n\\t\\t\\t\\tEdge incidentEdge = v.getOutEdge();\\n\\t\\t\\t\\tint firstEdgeId = incidentEdge.getId();\\n\\t\\t\\t\\tint chordCounter = -2; // the 2 neighbours are on the outer circle, but no chords\\n\\t\\t\\t\\tdo {\\n\\t\\t\\t\\t\\tif (onOuterCircle.contains(incidentEdge.getTarget())) {\\n\\t\\t\\t\\t\\t\\tchordCounter++;\\n\\t\\t\\t\\t\\t}\\n\\t\\t\\t\\t\\tincidentEdge = incidentEdge.getTwin().getNext();\\n\\t\\t\\t\\t} while (incidentEdge.getId() != firstEdgeId);\\n\\t\\t\\t\\tchords.put(v.getId(), chordCounter);\\n\\t\\t\\t}\\n\\t\\t}\\n\\t}\",\n \"public TriangleBumper(Double x,Double y,Double orientation,ListtriggeredGadgets){\\n this.x = x;\\n this.y = y;\\n this.collideCirc = new ArrayList(); //corner that ball will collide with\\n this.collideLine = new ArrayList(); //side that ball will collide with\\n this.orientation = orientation;\\n this.triggeredGadgets = new ArrayList<>();\\n for (Gadget gadget : triggeredGadgets){\\n this.triggeredGadgets.add(gadget);\\n }\\n //circle at each corner\\n //line segment at each side\\n if(this.orientation == 0.0){\\n this.circles = Arrays.asList(new Circle(x,y,0.0), new Circle(x, y+1, 0.0), new Circle(x+1, y, 0.0));\\n this.lines = Arrays.asList(new LineSegment(x+1, y, x, y+1), new LineSegment(x, y, x, y+1), new LineSegment(x,y, x+1, y));\\n }else if (this.orientation == 90.0){\\n this.circles = Arrays.asList(new Circle(x,y,0.0), new Circle(x+1, y, 0.0), new Circle(x+1, y+1,0.0));\\n this.lines = Arrays.asList(new LineSegment(x, y, x+1, y), new LineSegment(x+1, y, x+1, y+1), new LineSegment(x,y, x+1, y+1));\\n }else if (this.orientation == 180.0){\\n this.circles = Arrays.asList(new Circle(x,y+1, 0.0), new Circle(x+1, y, 0.0), new Circle(x+1, y+1, 0.0));\\n this.lines = Arrays.asList(new LineSegment(x, y+1, x+1, y), new LineSegment(x+1, y, x+1, y+1), new LineSegment(x+1, y+1, x, y+1));\\n }else{\\n this.circles = Arrays.asList(new Circle(x,y,0.0), new Circle(x, y+1, 0.0), new Circle(x+1, y+1, 0.0));\\n this.lines = Arrays.asList(new LineSegment(x,y,x, y+1), new LineSegment(x,y+1, x+1, y+1), new LineSegment(x+1, y+1, x, y));\\n }\\n checkRep();\\n\\n }\",\n \"@Override\\r\\n public Shape createShape(RenderContext ctx) {\\n float v[] = { -1, -1, 1, 1, -1, 1, 1, 1, 1, -1, 1, 1, // front face\\r\\n -1, -1, -1, -1, -1, 1, -1, 1, 1, -1, 1, -1, // left face\\r\\n -1, -1, 1, -1, -1, -1, 1, -1, -1, 1, -1, 1 }; // bottom face\\r\\n\\r\\n // The vertex normals\\r\\n float n[] = { 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, // front face\\r\\n -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, // left face\\r\\n 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0 }; // bottom face\\r\\n\\r\\n // The vertex colors\\r\\n float c[] = { 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, //\\r\\n 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, //\\r\\n 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1 };\\r\\n\\r\\n // Texture coordinates\\r\\n float uv[] = { 0, 0, 1, 0, 1, 1, 0, 1, //\\r\\n 0, 0, 1, 0, 1, 1, 0, 1, //\\r\\n 0, 0, 1, 0, 1, 1, 0, 1 };\\r\\n\\r\\n // The triangles (three vertex indices for each triangle)\\r\\n int indices[] = { 0, 2, 3, 0, 1, 2, // front face\\r\\n 4, 6, 7, 4, 5, 6, // left face\\r\\n 8, 10, 11, 8, 9, 10 }; // bottom face\\r\\n\\r\\n // Construct a data structure that stores the vertices, their\\r\\n // attributes, and the triangle mesh connectivity\\r\\n VertexData vertexData = ctx.makeVertexData(12);\\r\\n vertexData.addElement(c, VertexData.Semantic.COLOR, 3);\\r\\n vertexData.addElement(v, VertexData.Semantic.POSITION, 3);\\r\\n vertexData.addElement(n, VertexData.Semantic.NORMAL, 3);\\r\\n vertexData.addElement(uv, VertexData.Semantic.TEXCOORD, 2);\\r\\n vertexData.addIndices(indices);\\r\\n\\r\\n return new jrtr.Shape(vertexData);\\r\\n }\",\n \"private void setGeometryData() {\\n // allocate vertices\\n final int factorK = (innerRadius == 0 ? 1 : 2);\\n final int verts = factorK * ((zSamples - 2) * (radialSamples) + 2); // rs + 1\\n setVertexCoordsSize (verts);\\n setNormalCoordsSize (verts);\\n\\n // generate geometry\\n final double fInvRS = 1.0 / (radialSamples);\\n final double fZFactor = 1.0 / (zSamples - 1); // 2.0 / (zSamples - 1);\\n\\n // Generate points on the unit circle to be used in computing the mesh\\n // points on a sphere slice.\\n final double[] afSin = new double[(radialSamples + 1)];\\n final double[] afCos = new double[(radialSamples + 1)];\\n for ( int iR = 0; iR < radialSamples; iR++ ) {\\n final double fAngle = phi0 + dPhi * fInvRS * iR;\\n afCos[iR] = Math.cos (fAngle);\\n afSin[iR] = Math.sin (fAngle);\\n }\\n // afSin[radialSamples] = afSin[0];\\n // afCos[radialSamples] = afCos[0];\\n\\n double radDiff = Math.abs (outerRadius - innerRadius);\\n\\n for ( int icnt = 0; icnt < 2; icnt++ ) {\\n radius = (icnt == 0 ? innerRadius : outerRadius);\\n if ( radius == 0.0 ) {\\n continue;\\n }\\n double zNP = centerZ; // 0.0;\\n double zSP = centerZ; // 0.0;\\n\\n // generate the sphere itself\\n int i = 0;\\n Vector3D tempVa;\\n Vector3D kSliceCenter;\\n\\n for ( int iZ = 1; iZ < (zSamples - 1); iZ++ ) { // -1\\n //final double fAFraction = 0.5 * Math.PI * (-1.0f + fZFactor * iZ); // in (-pi/2, pi/2)\\n final double fAFraction = theta1 - iZ * fZFactor * dTheta;\\n final double fZFraction = Math.sin (fAFraction); // in (-1,1)\\n final double fZ = radius * fZFraction;\\n\\n // compute center of slice\\n kSliceCenter = new Vector3D (\\n center.getX (),\\n center.getY (),\\n center.getZ () + fZ\\n );\\n\\n // compute radius of slice\\n final double fSliceRadius = Math.sqrt (\\n Math.abs (\\n radius * radius - fZ * fZ\\n )\\n );\\n\\n // compute slice vertices with duplication at end point\\n Vector3D kNormal;\\n final int iSave = i;\\n for ( int iR = 0; iR < radialSamples; iR++ ) {\\n final double fRadialFraction = iR * fInvRS; // in [0,1)\\n final Vector3D kRadial = new Vector3D (\\n afCos[iR],\\n afSin[iR],\\n 0\\n );\\n tempVa = new Vector3D (\\n fSliceRadius * kRadial.getX (),\\n fSliceRadius * kRadial.getY (),\\n fSliceRadius * kRadial.getZ ()\\n );\\n\\n zNP = Math.\\n max (kSliceCenter.getZ (), zNP);\\n zSP = Math.\\n min (kSliceCenter.getZ (), zSP);\\n\\n putVertex (\\n (kSliceCenter.getX () + tempVa.getX ()),\\n (kSliceCenter.getY () + tempVa.getY ()),\\n (kSliceCenter.getZ () + tempVa.getZ ())\\n );\\n tempVa = getVertexCoord (i);\\n\\n kNormal = new Vector3D (\\n tempVa.getX () - center.getX (),\\n tempVa.getY () - center.getY (),\\n tempVa.getZ () - center.getZ ()\\n );\\n double mag = Math.sqrt (\\n Math.pow (kNormal.getX (), 2) +\\n Math.pow (kNormal.getY (), 2) +\\n Math.pow (kNormal.getZ (), 2)\\n );\\n kNormal = new Vector3D (\\n kNormal.getX () / mag,\\n kNormal.getY () / mag,\\n kNormal.getZ () / mag\\n );\\n if ( !viewInside ) {\\n putNormal (\\n kNormal.getX (),\\n kNormal.getY (),\\n kNormal.getZ ()\\n );\\n } else {\\n putNormal (\\n -kNormal.getX (),\\n -kNormal.getY (),\\n -kNormal.getZ ()\\n );\\n }\\n i++;\\n }\\n\\n// setVertexCoord(i, getVertexCoord(iSave));\\n// setNormalCoord(i, getNormalCoord(iSave));\\n putVertex (getVertexCoord (iSave));\\n putNormal (getNormalCoord (iSave));\\n i++;\\n }\\n\\n // south pole\\n if ( theta0 == -0.5 * Math.PI ) {\\n putVertex (new Vector3D (\\n center.getX (),\\n center.getY (),\\n (center.getZ () - radius)\\n ));\\n setVertexCount (i + 1);\\n if ( !viewInside ) {\\n putNormal (new Vector3D (0, 0, -1));\\n } else {\\n putNormal (new Vector3D (0, 0, 1));\\n }\\n setNormalCount (i + 1);\\n i++;\\n }\\n\\n // north pole\\n if ( theta1 == 0.5 * Math.PI ) {\\n putVertex (new Vector3D (\\n center.getX (),\\n center.getY (),\\n center.getZ () + radius\\n ));\\n setVertexCount (i + 1);\\n if ( !viewInside ) {\\n putNormal (new Vector3D (0, 0, 1));\\n } else {\\n putNormal (new Vector3D (0, 0, -1));\\n }\\n setNormalCount (i + 1);\\n i++;\\n }\\n }\\n\\n }\",\n \"public Cylinder(double radius, double height) {\\n\\t\\tthis.base = new Circle(radius);\\n\\t\\tthis.height = height;\\n\\t}\",\n \"public static DeformableMesh3D createTestBlock(double w, double h, double depth){\\n ArrayList pts = new ArrayList();\\n ArrayList connections = new ArrayList();\\n ArrayList triangles = new ArrayList();\\n\\n pts.add(new double[]{-w/2, -h/2, depth/2});\\n pts.add(new double[]{-w/2, h/2, depth/2});\\n pts.add(new double[]{w/2, h/2, depth/2});\\n pts.add(new double[]{w/2, -h/2, depth/2});\\n\\n pts.add(new double[]{-w/2, -h/2, -depth/2});\\n pts.add(new double[]{-w/2, h/2, -depth/2});\\n pts.add(new double[]{w/2, h/2, -depth/2});\\n pts.add(new double[]{w/2, -h/2, -depth/2});\\n\\n //back face\\n connections.add(new int[]{0, 4});\\n connections.add(new int[]{0, 1});\\n connections.add(new int[]{1, 5});\\n connections.add(new int[]{5, 4});\\n\\n //front face\\n connections.add(new int[]{3, 7});\\n connections.add(new int[]{2, 3});\\n connections.add(new int[]{2, 6});\\n connections.add(new int[]{6, 7});\\n\\n //front-back connections.\\n connections.add(new int[]{3, 0});\\n connections.add(new int[]{1, 2});\\n connections.add(new int[]{5, 6});\\n connections.add(new int[]{7, 4});\\n\\n //top\\n triangles.add(new int[]{0, 2, 1});\\n triangles.add(new int[]{0,3,2});\\n //top-diagonal\\n connections.add(new int[]{0, 2});\\n\\n //back\\n triangles.add(new int[]{0, 1, 5});\\n triangles.add(new int[]{0,5,4});\\n connections.add(new int[]{0, 5});\\n\\n //right\\n triangles.add(new int[]{1,2,5});\\n triangles.add(new int[]{5,2,6});\\n connections.add(new int[]{5, 2});\\n\\n //front\\n triangles.add(new int[]{2,3,6});\\n triangles.add(new int[]{6,3,7});\\n connections.add(new int[]{3, 6});\\n\\n //left\\n triangles.add(new int[]{3,0,4});\\n triangles.add(new int[]{3,4,7});\\n connections.add(new int[]{3, 4});\\n\\n //bottom\\n triangles.add(new int[]{4,5,6});\\n triangles.add(new int[]{4,6,7});\\n connections.add(new int[]{4, 6});\\n return new DeformableMesh3D(pts, connections, triangles);\\n\\n }\",\n \"private void BC_cylinder(Grid gr){\\r\\n int i, j, j1, j2;\\r\\n NSmax = (int)(500.0/dt); repL=0.1;\\r\\n // Boundary conditions of lower side of computational domain\\r\\n for(i = 0; i drawCylinder(Position origin, int radius, int height, boolean includeOrigin){\\n\\t\\tList cylinder = new ArrayList();\\n\\t\\tPosition pos = origin.get2DProjection();\\n\\t\\tfor(int i = 0; i < height; i++){\\n\\t\\t\\tPosition sliceOrigin = vectorAdd(pos, scalarMultiply(Direction.UP.getPosVector(), i));\\n\\t\\t\\tList ring = drawCircle(sliceOrigin, i, true);\\n\\t\\t\\tcylinder.addAll(ring);\\n\\t\\t}\\n\\t\\tif(!includeOrigin){\\n\\t\\t\\tcylinder.remove(origin);\\n\\t\\t}\\n\\t\\treturn cylinder;\\n\\t}\",\n \"Car(int x, int y) {\\n // ASSIGN ALL PARAMETERS TO THE CAR CLASS GLOBAL VARIABLES HERE\\n xCord = x;\\n yCord = y;\\n targetCord = 0;\\n // CREATE CAR PSHAPE HERE\\n // ATTEMPT TO CREATE A CAR-LOOKING-THING USING YOUR OWN VERTICES\\n\\n //front of car\\n //let's slam a bunch of vertices down and hope.\\n car = createShape();\\n fullCar = createShape(GROUP);\\n car.beginShape();\\n car.vertex(0, 20);\\n car.vertex(2, 10);\\n car.vertex(2.25f, 9);\\n car.vertex(3, 7);\\n car.vertex(4, 5);\\n car.vertex(5, 3);\\n car.vertex(6, 2);\\n car.vertex(7, 1);\\n car.vertex(8, .33f);\\n car.vertex(9, .1f);\\n car.vertex(10, 0);\\n car.vertex(20, 0);\\n\\n car.vertex(21, .1f);\\n car.vertex(22, .33f);\\n car.vertex(23, 1);\\n car.vertex(24, 2);\\n car.vertex(25, 3);\\n car.vertex(26, 5);\\n car.vertex(27, 7);\\n car.vertex(27.75f, 9);\\n car.vertex(28, 10);\\n car.vertex(30, 20);\\n ////hood curve\\n car.vertex(0, 20);\\n car.vertex(0, 50);\\n car.vertex(30, 50);\\n car.vertex(30, 20);\\n car.endShape(CLOSE);\\n\\n\\n ////main body\\n //have as three shape groups on top\\n carTopLeft = createShape();\\n carTopLeft.beginShape();\\n carTopLeft.vertex(7, 24);\\n carTopLeft.vertex(0, 50);\\n carTopLeft.vertex(0, 20);\\n carTopLeft.vertex(7, 24);\\n carTopLeft.endShape(CLOSE);\\n\\n carTopRight = createShape();\\n carTopRight.beginShape();\\n carTopRight.vertex(23, 24);\\n carTopRight.vertex(30, 50);\\n carTopRight.vertex(30, 20);\\n carTopRight.vertex(23, 24);\\n carTopRight.endShape(CLOSE);\\n\\n carTop = createShape();\\n carTop.beginShape();\\n carTop.vertex(23, 24);\\n\\n carTop.vertex(15, 21);\\n\\n carTop.vertex(7, 24);\\n carTop.vertex(0, 50);\\n carTop.vertex(30, 50);\\n carTop.vertex(23, 24);\\n carTop.endShape(CLOSE);\\n //car.vertex(23,24);\\n //car.vertex(30,50);\\n //car.vertex(30,20);\\n //car.vertex(23,24);\\n //car.vertex(22,23.25);\\n //car.vertex(21,22.6);\\n //car.vertex(20,22.1);\\n //car.vertex(19,21.8);\\n //car.vertex(18,21.4);\\n //car.vertex(17,21.2);\\n //car.vertex(16,21.1);\\n //car.vertex(15,21);\\n\\n //car.vertex(14,21.1);\\n //car.vertex(13,21.2);\\n //car.vertex(12,21.4);\\n //car.vertex(11,21.8);\\n //car.vertex(10,22.1);\\n //car.vertex(9,22.6);\\n //car.vertex(8,23.25);\\n //car.vertex(7,24);\\n //car.vertex(0,50);\\n //car.vertex(0,20);\\n //car.vertex(7,24);\\n //car.vertex(0,50);\\n ////top details\\n\\n ////rear\\n //test vertex\\n carRear = createShape();\\n carRear.beginShape();\\n carRear.vertex(0, 50);\\n carRear.vertex(0, 70);\\n carRear.vertex(1, 71.2f);\\n carRear.vertex(2, 72.33f);\\n carRear.vertex(3, 73);\\n carRear.vertex(4, 73.25f);\\n carRear.vertex(5, 73.75f);\\n carRear.vertex(6, 74);\\n carRear.vertex(7, 74.2f);\\n carRear.vertex(8, 74.4f);\\n carRear.vertex(9, 74.6f);\\n carRear.vertex(10, 74.8f);\\n // carRear.vertex(11,74.85);\\n // carRear.vertex(12,74.9);\\n //carRear.vertex(14,74.95); \\n carRear.vertex(15, 75);\\n //carRear.vertex(16,74.95); \\n //carRear.vertex(17,74.93);\\n //carRear.vertex(18,74.9);\\n carRear.vertex(19, 74.85f);\\n carRear.vertex(20, 74.8f);\\n carRear.vertex(21, 74.6f);\\n carRear.vertex(22, 74.4f);\\n carRear.vertex(23, 74.2f);\\n carRear.vertex(24, 74);\\n carRear.vertex(25, 73.75f);\\n carRear.vertex(26, 73.25f);\\n carRear.vertex(27, 73);\\n carRear.vertex(28, 72.33f);\\n carRear.vertex(29, 71.2f);\\n carRear.vertex(30, 70);\\n carRear.vertex(30, 50);\\n carRear.endShape(CLOSE);\\n //FINISH THE PSHAPE WITH YOUR CUSTOM VERTICES\\n\\n //it worked\\n\\n // ADD WHEELS TO THE CAR (ELLIPSES)\\n //leftWheel = createShape(ELLIPSE, xCoord +10, yCoord + 25, 8, 8);\\n // rightWheel = createShape(ELLIPSE, xCoord +45, yCoord + 25, 8, 8);\\n\\n //groups everything together\\n fullCar.addChild(car);\\n fullCar.addChild(carRear);\\n fullCar.addChild(carTopLeft);\\n fullCar.addChild(carTopRight);\\n fullCar.addChild(carTop);\\n // fullCar.addChild(leftWheel);\\n // fullCar.addChild(rightWheel);\\n }\",\n \"static void createCubes(double width, double height) {\\n \\t\\r\\n \\tmaxY=f(startingBound);\\r\\n \\tmaxX=startingBound;\\r\\n \\t\\r\\n \\t//need a function to find the max\\r\\n \\tfor(double i=startingBound; i<=endingBound; i=i+dx) {\\r\\n \\t\\tif(f(i)>maxY)\\r\\n \\t\\t\\tmaxY=f(i);\\r\\n \\t\\t\\r\\n \\t\\tif(i>maxX)\\r\\n \\t\\t\\tmaxX=i;\\r\\n \\t}\\r\\n \\tdouble size=height/2-100;\\r\\n \\tSystem.out.println(size);\\r\\n \\tscaleY=maxY/(size);\\r\\n \\tscaleX=(width-100)/maxX;\\r\\n \\t\\r\\n \\tfor(double x=startingBound; x<=endingBound; x=x+dx) {\\r\\n \\t\\t//System.out.println(x+\\\", \\\"+f(x));\\r\\n \\t\\tcubes.add(new Cube(x*scaleX, -f(x)/scaleY, 0, f(x)/scaleY, dx*scaleX));\\r\\n \\t\\t//cubes.add(new Cube(x, 100, 0, 100, 100));\\r\\n \\t}\\r\\n \\t\\r\\n \\t\\r\\n }\",\n \"public CubeGL2(double width, double height, double depth) {\\n // Define points for a cube.\\n // X, Y, Z\\n mCubeVertexData = new float[]\\n {\\n // Front face\\n -1.0f, 1.0f, 1.0f,\\n -1.0f, -1.0f, 1.0f,\\n 1.0f, 1.0f, 1.0f,\\n -1.0f, -1.0f, 1.0f,\\n 1.0f, -1.0f, 1.0f,\\n 1.0f, 1.0f, 1.0f,\\n // Right face\\n 1.0f, 1.0f, 1.0f,\\n 1.0f, -1.0f, 1.0f,\\n 1.0f, 1.0f, -1.0f,\\n 1.0f, -1.0f, 1.0f,\\n 1.0f, -1.0f, -1.0f,\\n 1.0f, 1.0f, -1.0f,\\n // Back face\\n 1.0f, 1.0f, -1.0f,\\n 1.0f, -1.0f, -1.0f,\\n -1.0f, 1.0f, -1.0f,\\n 1.0f, -1.0f, -1.0f,\\n -1.0f, -1.0f, -1.0f,\\n -1.0f, 1.0f, -1.0f,\\n // Left face\\n -1.0f, 1.0f, -1.0f,\\n -1.0f, -1.0f, -1.0f,\\n -1.0f, 1.0f, 1.0f,\\n -1.0f, -1.0f, -1.0f,\\n -1.0f, -1.0f, 1.0f,\\n -1.0f, 1.0f, 1.0f,\\n // Top face\\n -1.0f, 1.0f, -1.0f,\\n -1.0f, 1.0f, 1.0f,\\n 1.0f, 1.0f, -1.0f,\\n -1.0f, 1.0f, 1.0f,\\n 1.0f, 1.0f, 1.0f,\\n 1.0f, 1.0f, -1.0f,\\n // Bottom face\\n 1.0f, -1.0f, -1.0f,\\n 1.0f, -1.0f, 1.0f,\\n -1.0f, -1.0f, -1.0f,\\n 1.0f, -1.0f, 1.0f,\\n -1.0f, -1.0f, 1.0f,\\n -1.0f, -1.0f, -1.0f,\\n };\\n\\n for (int i = 0; i < mCubeVertexData.length; i += 3) {\\n mCubeVertexData[i] = mCubeVertexData[i] * (float) width;\\n }\\n for (int i = 1; i < mCubeVertexData.length; i += 3) {\\n mCubeVertexData[i] = mCubeVertexData[i] * (float) height;\\n }\\n for (int i = 2; i < mCubeVertexData.length; i += 3) {\\n mCubeVertexData[i] = mCubeVertexData[i] * (float) depth;\\n }\\n\\n // R, G, B, A\\n mCubeColourData = new float[]\\n {\\n // Front face\\n 1.0f, 0.0f, 0.0f, 1.0f,\\n 1.0f, 0.0f, 0.0f, 1.0f,\\n 1.0f, 0.0f, 0.0f, 1.0f,\\n 1.0f, 0.0f, 0.0f, 1.0f,\\n 1.0f, 0.0f, 0.0f, 1.0f,\\n 1.0f, 0.0f, 0.0f, 1.0f,\\n // Right face\\n 0.0f, 1.0f, 0.0f, 1.0f,\\n 0.0f, 1.0f, 0.0f, 1.0f,\\n 0.0f, 1.0f, 0.0f, 1.0f,\\n 0.0f, 1.0f, 0.0f, 1.0f,\\n 0.0f, 1.0f, 0.0f, 1.0f,\\n 0.0f, 1.0f, 0.0f, 1.0f,\\n // Back face\\n 0.0f, 0.0f, 1.0f, 1.0f,\\n 0.0f, 0.0f, 1.0f, 1.0f,\\n 0.0f, 0.0f, 1.0f, 1.0f,\\n 0.0f, 0.0f, 1.0f, 1.0f,\\n 0.0f, 0.0f, 1.0f, 1.0f,\\n 0.0f, 0.0f, 1.0f, 1.0f,\\n // Left face\\n 1.0f, 1.0f, 0.0f, 1.0f,\\n 1.0f, 1.0f, 0.0f, 1.0f,\\n 1.0f, 1.0f, 0.0f, 1.0f,\\n 1.0f, 1.0f, 0.0f, 1.0f,\\n 1.0f, 1.0f, 0.0f, 1.0f,\\n 1.0f, 1.0f, 0.0f, 1.0f,\\n // Top face\\n 0.0f, 1.0f, 1.0f, 1.0f,\\n 0.0f, 1.0f, 1.0f, 1.0f,\\n 0.0f, 1.0f, 1.0f, 1.0f,\\n 0.0f, 1.0f, 1.0f, 1.0f,\\n 0.0f, 1.0f, 1.0f, 1.0f,\\n 0.0f, 1.0f, 1.0f, 1.0f,\\n // Bottom face\\n 1.0f, 0.0f, 1.0f, 1.0f,\\n 1.0f, 0.0f, 1.0f, 1.0f,\\n 1.0f, 0.0f, 1.0f, 1.0f,\\n 1.0f, 0.0f, 1.0f, 1.0f,\\n 1.0f, 0.0f, 1.0f, 1.0f,\\n 1.0f, 0.0f, 1.0f, 1.0f\\n };\\n // X, Y, Z\\n mCubeNormalData = new float[]\\n {\\n // Front face\\n 0.0f, 0.0f, 1.0f,\\n 0.0f, 0.0f, 1.0f,\\n 0.0f, 0.0f, 1.0f,\\n 0.0f, 0.0f, 1.0f,\\n 0.0f, 0.0f, 1.0f,\\n 0.0f, 0.0f, 1.0f,\\n // Right face\\n 1.0f, 0.0f, 0.0f,\\n 1.0f, 0.0f, 0.0f,\\n 1.0f, 0.0f, 0.0f,\\n 1.0f, 0.0f, 0.0f,\\n 1.0f, 0.0f, 0.0f,\\n 1.0f, 0.0f, 0.0f,\\n // Back face\\n 0.0f, 0.0f, -1.0f,\\n 0.0f, 0.0f, -1.0f,\\n 0.0f, 0.0f, -1.0f,\\n 0.0f, 0.0f, -1.0f,\\n 0.0f, 0.0f, -1.0f,\\n 0.0f, 0.0f, -1.0f,\\n // Left face\\n -1.0f, 0.0f, 0.0f,\\n -1.0f, 0.0f, 0.0f,\\n -1.0f, 0.0f, 0.0f,\\n -1.0f, 0.0f, 0.0f,\\n -1.0f, 0.0f, 0.0f,\\n -1.0f, 0.0f, 0.0f,\\n // Top face\\n 0.0f, 1.0f, 0.0f,\\n 0.0f, 1.0f, 0.0f,\\n 0.0f, 1.0f, 0.0f,\\n 0.0f, 1.0f, 0.0f,\\n 0.0f, 1.0f, 0.0f,\\n 0.0f, 1.0f, 0.0f,\\n // Bottom face\\n 0.0f, -1.0f, 0.0f,\\n 0.0f, -1.0f, 0.0f,\\n 0.0f, -1.0f, 0.0f,\\n 0.0f, -1.0f, 0.0f,\\n 0.0f, -1.0f, 0.0f,\\n 0.0f, -1.0f, 0.0f\\n };\\n // X, Y\\n // Texture coordinate data.\\n mCubeTextureCoordinateData = new float[]\\n {\\n // Front face\\n 0.0f, 0.0f,\\n 0.0f, 1.0f,\\n 1.0f, 0.0f,\\n 0.0f, 1.0f,\\n 1.0f, 1.0f,\\n 1.0f, 0.0f,\\n // Right face\\n 0.0f, 0.0f,\\n 0.0f, 1.0f,\\n 1.0f, 0.0f,\\n 0.0f, 1.0f,\\n 1.0f, 1.0f,\\n 1.0f, 0.0f,\\n // Back face\\n 0.0f, 0.0f,\\n 0.0f, 1.0f,\\n 1.0f, 0.0f,\\n 0.0f, 1.0f,\\n 1.0f, 1.0f,\\n 1.0f, 0.0f,\\n // Left face\\n 0.0f, 0.0f,\\n 0.0f, 1.0f,\\n 1.0f, 0.0f,\\n 0.0f, 1.0f,\\n 1.0f, 1.0f,\\n 1.0f, 0.0f,\\n // Top face\\n 0.0f, 0.0f,\\n 0.0f, 1.0f,\\n 1.0f, 0.0f,\\n 0.0f, 1.0f,\\n 1.0f, 1.0f,\\n 1.0f, 0.0f,\\n // Bottom face\\n 0.0f, 0.0f,\\n 0.0f, 1.0f,\\n 1.0f, 0.0f,\\n 0.0f, 1.0f,\\n 1.0f, 1.0f,\\n 1.0f, 0.0f\\n };\\n // Initialize the buffers.\\n mCubeVertices = ByteBuffer.allocateDirect(mCubeVertexData.length * 4)\\n .order(ByteOrder.nativeOrder()).asFloatBuffer();\\n mCubeVertices.put(mCubeVertexData).position(0);\\n mCubeColours = ByteBuffer.allocateDirect(mCubeColourData.length * 4)\\n .order(ByteOrder.nativeOrder()).asFloatBuffer();\\n mCubeColours.put(mCubeColourData).position(0);\\n mCubeNormals = ByteBuffer.allocateDirect(mCubeNormalData.length * 4)\\n .order(ByteOrder.nativeOrder()).asFloatBuffer();\\n mCubeNormals.put(mCubeNormalData).position(0);\\n mCubeTextureCoordinates = ByteBuffer.allocateDirect(mCubeTextureCoordinateData.length * 4)\\n .order(ByteOrder.nativeOrder()).asFloatBuffer();\\n mCubeTextureCoordinates.put(mCubeTextureCoordinateData).position(0);\\n Matrix.setIdentityM(mModelMatrix, 0);\\n }\",\n \"public Polygon getPolygon(double eyeDistance){\\n //define the front two verticies of the currentTrack\\n Point3D track_vertex0 = currentTrack.getVertex(0);\\n Point3D track_vertex1 = currentTrack.getVertex(1);\\n //use center point to define the center of the sphape\\n int cubeSize = 3;\\n\\n Point3D front_up_left = new Point3D (centerPoint.x-cubeSize, centerPoint.y-cubeSize, centerPoint.z-cubeSize);\\n Point3D front_down_left = new Point3D (centerPoint.x-cubeSize, centerPoint.y+cubeSize, centerPoint.z-cubeSize);\\n Point3D front_down_right = new Point3D (centerPoint.x+cubeSize, centerPoint.y+cubeSize, centerPoint.z-cubeSize);\\n Point3D front_up_right = new Point3D (centerPoint.x+cubeSize, centerPoint.y-cubeSize, centerPoint.z-cubeSize);\\n\\n Point3D back_up_left = new Point3D (front_up_left.x, front_up_left.y, centerPoint.z+cubeSize);\\n Point3D back_down_left = new Point3D (front_down_left.x, front_down_left.y, centerPoint.z+cubeSize);\\n Point3D back_down_right = new Point3D (front_down_right.x, front_down_right.y, centerPoint.z+cubeSize);\\n Point3D back_up_right = new Point3D (front_up_right.x, front_up_right.y, centerPoint.z+cubeSize);\\n\\n //aranges verticies in the order they will be drawn\\n Point3D[] cube_verticies = {front_up_left, front_down_left, front_down_right, front_up_right,\\n front_up_left, back_up_left, back_up_right, front_up_right,\\n front_down_right, back_down_right, back_up_right, back_down_right,\\n back_down_left, back_up_left, back_down_left, front_down_left};\\n\\n int[] x_points = new int[16];\\n int[] y_points = new int[16];\\n //convert 3D points to 2D points\\n for(int i=0;i<16;i++){\\n if(cube_verticies[i].z <= 200){ //same fix as for the track positioning\\n x_points[i] = (int) -cube_verticies[i].projectPoint3D(eyeDistance).getX();\\n y_points[i] = (int) cube_verticies[i].projectPoint3D(eyeDistance).getY();\\n }\\n else{\\n x_points[i] = (int) cube_verticies[i].projectPoint3D(eyeDistance).getX();\\n y_points[i] = (int) cube_verticies[i].projectPoint3D(eyeDistance).getY();\\n }\\n }\\n Polygon polygon = new Polygon(x_points, y_points, 16);\\n return polygon;\\n }\",\n \"public Cylinder(double height, double radius, boolean Center) {\\n\\t\\tsuper();\\n\\t\\tthis.height = height;\\n\\t\\tthis.radius = radius;\\n\\t\\tthis.center = Center;\\n\\t}\",\n \"public void makeSphere (float radius, int slices, int stacks)\\r\\n {\\r\\n \\t\\r\\n \\tPoint lower[][] = new Point[stacks + 1][slices + 1];\\r\\n \\tfloat rad[] = new float[stacks + 1];\\r\\n \\tfloat vert = -0.5f;\\r\\n \\t\\r\\n \\t// Calculate radius for each stack\\r\\n \\tfor(int i = 0; i <= stacks; i ++)\\r\\n \\t{\\r\\n \\t\\trad[i] = (float)Math.sqrt((0.5f * 0.5f) - (( 0.5f - ( ( 1.0f/(float)stacks) * i ) ) * ( 0.5f - ( ( 1.0f/(float)stacks) * i ) ) ));\\r\\n\\t\\t}\\r\\n \\t\\r\\n \\tvert = -0.5f;\\r\\n \\t\\r\\n \\t// Calculate the vertices for each stack\\r\\n \\tfor(int i = 0; i <= stacks; i ++ )\\r\\n \\t{\\r\\n \\t\\tfor(int j = 0; j <= slices; j ++)\\r\\n \\t\\t{\\r\\n \\t\\t\\tlower[i][j] = new Point();\\r\\n \\t\\t\\tlower[i][j].x = rad[i] * (float)Math.cos(Math.toRadians ( (360.0f / (float)slices) * j ) );\\r\\n \\t\\t\\tlower[i][j].z = rad[i] * (float)Math.sin(Math.toRadians ( (360.0f / (float)slices) * j ) );\\r\\n \\t\\t\\tlower[i][j].y = vert;\\r\\n \\t\\t}\\r\\n \\t\\t// Update the y coordinate for the next stack\\r\\n \\t\\tvert += (1.0f / (float)stacks);\\r\\n \\t}\\r\\n \\t\\r\\n \\t\\r\\n \\t// Print all the triangles using the vertices\\r\\n \\tfor(int i = 0 ; i < stacks; i++)\\r\\n \\t\\tfor(int j = 0 ; j < slices; j++)\\r\\n \\t\\t{\\r\\n \\t\\t\\tthis.addTriangle(lower[i][j].x, lower[i][j].y, lower[i][j].z, lower[i][j+1].x, lower[i][j+1].y, lower[i][j+1].z, lower[i+1][j+1].x, lower[i+1][j+1].y, lower[i+1][j+1].z);\\r\\n \\t\\t\\tthis.addTriangle(lower[i][j].x, lower[i][j].y, lower[i][j].z, lower[i+1][j+1].x, lower[i+1][j+1].y, lower[i+1][j+1].z, lower[i+1][j].x, lower[i+1][j].y, lower[i+1][j].z);\\r\\n \\t\\t}\\r\\n }\",\n \"public void draw() {\\n\\t\\tapplyColors();\\n\\n\\t\\tfloat halfHeight = height / 2,\\n\\t\\t\\t\\tdiameter = 2 * radius;\\n\\n\\t\\tRobotRun.getInstance().translate(0f, 0f, halfHeight);\\n\\t\\t// Draw top of the cylinder\\n\\t\\tRobotRun.getInstance().ellipse(0f, 0f, diameter, diameter);\\n\\t\\tRobotRun.getInstance().translate(0f, 0f, -height);\\n\\t\\t// Draw bottom of the cylinder\\n\\t\\tRobotRun.getInstance().ellipse(0f, 0f, diameter, diameter);\\n\\t\\tRobotRun.getInstance().translate(0f, 0f, halfHeight);\\n\\n\\t\\tRobotRun.getInstance().beginShape(RobotRun.TRIANGLE_STRIP);\\n\\t\\t// Draw a string of triangles around the circumference of the Cylinders top and bottom.\\n\\t\\tfor (int degree = 0; degree <= 360; ++degree) {\\n\\t\\t\\tfloat pos_x = RobotRun.cos(RobotRun.DEG_TO_RAD * degree) * radius,\\n\\t\\t\\t\\t\\tpos_y = RobotRun.sin(RobotRun.DEG_TO_RAD * degree) * radius;\\n\\n\\t\\t\\tRobotRun.getInstance().vertex(pos_x, pos_y, halfHeight);\\n\\t\\t\\tRobotRun.getInstance().vertex(pos_x, pos_y, -halfHeight);\\n\\t\\t}\\n\\n\\t\\tRobotRun.getInstance().endShape();\\n\\t}\",\n \"public DiscMesh(float radius, int numVertices) {\\n Validate.nonNegative(radius, \\\"radius\\\");\\n Validate.inRange(\\n numVertices, \\\"number of vertices\\\", 3, Integer.MAX_VALUE);\\n\\n setMode(Mode.TriangleFan);\\n\\n float[] normals = new float[numAxes * numVertices];\\n float[] positions = new float[numAxes * numVertices];\\n float[] texCoords = new float[2 * numVertices];\\n\\n for (int vi = 0; vi < numVertices; ++vi) {\\n normals[numAxes * vi] = 0f;\\n normals[numAxes * vi + 1] = 0f;\\n normals[numAxes * vi + 2] = 1f;\\n\\n float theta = FastMath.TWO_PI * vi / numVertices;\\n float sin = FastMath.sin(theta);\\n float cos = FastMath.cos(theta);\\n positions[numAxes * vi] = radius * cos;\\n positions[numAxes * vi + 1] = radius * sin;\\n positions[numAxes * vi + 2] = 0f;\\n\\n texCoords[2 * vi] = (1f + cos) / 2f;\\n texCoords[2 * vi + 1] = (1f + sin) / 2f;\\n }\\n\\n setBuffer(Type.Normal, numAxes, normals);\\n setBuffer(Type.Position, numAxes, positions);\\n setBuffer(Type.TexCoord, 2, texCoords);\\n\\n updateBound();\\n setStatic();\\n }\",\n \"public Cylinder() {\\n\\t\\tthis(1.0);\\n\\t}\",\n \"private void createTrackContour(ArrayList contour, double radius) {\\r\\n // Create vertices for the left half circle\\r\\n for (int alpha = 90; alpha <= 270; alpha++) {\\r\\n // A contours vertex (coordinates, color, texture)\\r\\n double vertex[] = new double[9];\\r\\n\\r\\n // Apply color\\r\\n vertex[3] = trackColor.getRed();\\r\\n vertex[4] = trackColor.getGreen();\\r\\n vertex[5] = trackColor.getBlue();\\r\\n vertex[6] = trackColor.getAlpha();\\r\\n\\r\\n // Apply texture coordinates (no texture)\\r\\n vertex[7] = vertex[8] = 0;\\r\\n\\r\\n // Calculate the coordinates of a point lying on the half circle\\r\\n double u, v;\\r\\n\\r\\n u = Math.cos(alpha * (Math.PI / 180)) * radius;\\r\\n v = Math.sin(alpha * (Math.PI / 180)) * radius;\\r\\n\\r\\n // Apply coordinates\\r\\n vertex[0] = x1 + u;\\r\\n vertex[1] = y1 + v;\\r\\n vertex[2] = 0;\\r\\n\\r\\n // Add the vertex to the contour list\\r\\n contour.add(vertex);\\r\\n }\\r\\n\\r\\n // Create vertices for the right half circle\\r\\n for (int alpha = 270; alpha <= 450; alpha++) {\\r\\n // A contours vertex (coordinates, color, texture)\\r\\n double vertex[] = new double[9];\\r\\n\\r\\n // Apply color\\r\\n vertex[3] = trackColor.getRed();\\r\\n vertex[4] = trackColor.getGreen();\\r\\n vertex[5] = trackColor.getBlue();\\r\\n vertex[6] = trackColor.getAlpha();\\r\\n\\r\\n // Apply texture coordinates (no texture)\\r\\n vertex[7] = vertex[8] = 0;\\r\\n\\r\\n // Calculate the coordinates of a point lying on the half circle\\r\\n double u, v;\\r\\n\\r\\n u = Math.cos(alpha * (Math.PI / 180)) * radius;\\r\\n v = Math.sin(alpha * (Math.PI / 180)) * radius;\\r\\n\\r\\n // Apply coordinates\\r\\n vertex[0] = x2 + u;\\r\\n vertex[1] = y2 + v;\\r\\n vertex[2] = 0;\\r\\n\\r\\n // Add the vertex to the contour list\\r\\n contour.add(vertex);\\r\\n }\\r\\n }\",\n \"public Vector2f[] generatePatch(){\\n\\t\\tVector2f[] vertices = new Vector2f[16];\\n\\t\\t\\n\\t\\tint index = 0;\\n\\t\\t\\n\\t\\tvertices[index++] = new Vector2f(0,0);\\n\\t\\tvertices[index++] = new Vector2f(0.333f,0);\\n\\t\\tvertices[index++] = new Vector2f(0.666f,0);\\n\\t\\tvertices[index++] = new Vector2f(1,0);\\n\\t\\t\\n\\t\\tvertices[index++] = new Vector2f(0,0.333f);\\n\\t\\tvertices[index++] = new Vector2f(0.333f,0.333f);\\n\\t\\tvertices[index++] = new Vector2f(0.666f,0.333f);\\n\\t\\tvertices[index++] = new Vector2f(1,0.333f);\\n\\t\\t\\n\\t\\tvertices[index++] = new Vector2f(0,0.666f);\\n\\t\\tvertices[index++] = new Vector2f(0.333f,0.666f);\\n\\t\\tvertices[index++] = new Vector2f(0.666f,0.666f);\\n\\t\\tvertices[index++] = new Vector2f(1,0.666f);\\n\\t\\n\\t\\tvertices[index++] = new Vector2f(0,1);\\n\\t\\tvertices[index++] = new Vector2f(0.333f,1);\\n\\t\\tvertices[index++] = new Vector2f(0.666f,1);\\n\\t\\tvertices[index++] = new Vector2f(1,1);\\n\\t\\t\\n\\t\\treturn vertices;\\n\\t}\",\n \"public static double cylinderVolume(double radius, double height){\\n return Math.PI * square(radius) * height;\\n }\",\n \"public CylinderPanel() {\\n\\t\\t\\n\\t\\trInput = new JLabel(\\\"R = \\\");\\n\\t\\trInput.setAlignmentX(JLabel.RIGHT_ALIGNMENT);\\n\\t rInput.setHorizontalAlignment(JLabel.RIGHT);\\n\\t\\thInput = new JLabel(\\\"H = \\\");\\n\\t\\thInput.setAlignmentX(JLabel.RIGHT_ALIGNMENT);\\n\\t hInput.setHorizontalAlignment(JLabel.RIGHT);\\n\\t\\tvOutput = new JLabel(\\\"Volume: \\\");\\n\\t\\tvOutput.setAlignmentX(JLabel.RIGHT_ALIGNMENT);\\n\\t vOutput.setHorizontalAlignment(JLabel.RIGHT);\\n\\t\\tsaOutput = new JLabel(\\\"Surface Area: \\\");\\n\\t\\tsaOutput.setAlignmentX(JLabel.RIGHT_ALIGNMENT);\\n\\t saOutput.setHorizontalAlignment(JLabel.RIGHT);\\n\\t\\tvResult = new JLabel(\\\" --\\\");\\n\\t\\tsaResult = new JLabel(\\\" --\\\");\\n\\t\\t\\n\\t\\trText = new JTextField(10);\\n\\t\\thText = new JTextField(10);\\n\\t\\t\\n\\t\\tclear = new JButton(\\\"Clear\\\");\\n\\t\\tcalculate = new JButton(\\\"Calculate\\\");\\n\\t\\t\\n\\t\\ts = new Cylinder();\\n\\t\\t\\n\\t\\tsetBorder(BorderFactory.createTitledBorder(\\\"Cylinder\\\"));\\n\\t\\t\\n\\t\\tadd(rInput);\\n\\t\\tadd(rText);\\n\\t\\tadd(hInput);\\n\\t\\tadd(hText);\\n\\t\\tadd(vOutput);\\n\\t\\tadd(vResult);\\n\\t\\tadd(saOutput);\\n\\t\\tadd(saResult);\\n\\t\\tadd(clear);\\n\\t\\tadd(calculate);\\n\\t\\t\\n\\t\\tButtonListener listener = new ButtonListener();\\n\\t\\t\\n\\t\\tclear.addActionListener(listener);\\n\\t\\tcalculate.addActionListener(listener);\\n\\t\\t\\n\\t\\t\\n\\t}\",\n \"public static double volumeCylinder( double radius, double height ) {\\n return Math.PI * areaCircle(radius) * height;\\n }\",\n \"public static double cylinderArea(double r, double h) {\\r\\n return 2 * Math.PI * r * h + 2 * Math.PI * r * r;\\r\\n }\",\n \"public abstract void constructHull();\",\n \"public static Cylinder buildRobotCylinder() {\\n Cylinder robotCylinder = new Cylinder(\\n ROBOT_CYLINDER_LENGTH,\\n ROBOT_CYLINDER_RADIUS,\\n CYLINDER_NUM_LENGTH_SEGMENTS,\\n CYLINDER_NUM_CIRCLE_SEGMENTS\\n );\\n Material m = new Material(true);\\n m.setColor(COLOR_BLUE_50_TRANSPARENT);\\n robotCylinder.setMaterial(m);\\n robotCylinder.setTransparent(true);\\n robotCylinder.setDoubleSided(true);\\n robotCylinder.rotate(Vector3.Axis.X, 90.0); // Vertical, like the Y-axis\\n\\n return robotCylinder;\\n }\",\n \"public float[] makeVertices(float radius, float[] color)\\n {\\n int noOfComponents = 3 + 3 + 3; // 3 position coordinates, 3 color coordinates, 3 normal coordinates\\n float[] vertices = new float[(verticalResolution+1) * horizontalResolution * noOfComponents];\\n int vertexNumberInc = 3 + 3 + 3; // three position coordinates, three color values, three normal coordinates\\n int vertexNumber = 0;\\n\\n float elevation = 0;\\n float elevationInc = (float) (Math.PI / verticalResolution);\\n float azimuth = 0;\\n float azimuthInc = (float) (2* Math.PI / horizontalResolution);\\n for(int elevationIndex = 0; elevationIndex <= verticalResolution; elevationIndex++) {\\n azimuth = 0;\\n for(int azimuthIndex = 0; azimuthIndex < horizontalResolution; azimuthIndex++) {\\n // position coordinates in spherical coordinates\\n float xPos = radius * (float) (Math.sin(elevation) * Math.cos(azimuth));\\n float yPos = radius * (float) (Math.sin(elevation) * Math.sin(azimuth));\\n float zPos = radius * (float) Math.cos(elevation);\\n vertices[vertexNumber] = xPos;\\n vertices[vertexNumber+1] = yPos;\\n vertices[vertexNumber+2] = zPos;\\n // color coordinates (for all vertices the same)\\n vertices[vertexNumber+3] = color[0];\\n vertices[vertexNumber+4] = color[1];\\n vertices[vertexNumber+5] = color[2];\\n // coordinates of normal vector\\n // for a sphere this vector is identical to the normalizes position vector\\n float normalizationFactor = 1 / (float) Math.sqrt((xPos * xPos) + (yPos * yPos) + (zPos * zPos));\\n vertices[vertexNumber+6] = xPos * normalizationFactor;\\n vertices[vertexNumber+7] = yPos * normalizationFactor;\\n vertices[vertexNumber+8] = zPos * normalizationFactor;\\n\\n vertexNumber += vertexNumberInc;\\n azimuth += azimuthInc;\\n }\\n elevation += elevationInc;\\n }\\n return vertices;\\n }\",\n \"public CubeGL2() {\\n // Define points for a cube.\\n // X, Y, Z\\n mCubeVertexData = new float[]\\n {\\n // Front face\\n -1.0f, 1.0f, 1.0f,\\n -1.0f, -1.0f, 1.0f,\\n 1.0f, 1.0f, 1.0f,\\n -1.0f, -1.0f, 1.0f,\\n 1.0f, -1.0f, 1.0f,\\n 1.0f, 1.0f, 1.0f,\\n // Right face\\n 1.0f, 1.0f, 1.0f,\\n 1.0f, -1.0f, 1.0f,\\n 1.0f, 1.0f, -1.0f,\\n 1.0f, -1.0f, 1.0f,\\n 1.0f, -1.0f, -1.0f,\\n 1.0f, 1.0f, -1.0f,\\n // Back face\\n 1.0f, 1.0f, -1.0f,\\n 1.0f, -1.0f, -1.0f,\\n -1.0f, 1.0f, -1.0f,\\n 1.0f, -1.0f, -1.0f,\\n -1.0f, -1.0f, -1.0f,\\n -1.0f, 1.0f, -1.0f,\\n // Left face\\n -1.0f, 1.0f, -1.0f,\\n -1.0f, -1.0f, -1.0f,\\n -1.0f, 1.0f, 1.0f,\\n -1.0f, -1.0f, -1.0f,\\n -1.0f, -1.0f, 1.0f,\\n -1.0f, 1.0f, 1.0f,\\n // Top face\\n -1.0f, 1.0f, -1.0f,\\n -1.0f, 1.0f, 1.0f,\\n 1.0f, 1.0f, -1.0f,\\n -1.0f, 1.0f, 1.0f,\\n 1.0f, 1.0f, 1.0f,\\n 1.0f, 1.0f, -1.0f,\\n // Bottom face\\n 1.0f, -1.0f, -1.0f,\\n 1.0f, -1.0f, 1.0f,\\n -1.0f, -1.0f, -1.0f,\\n 1.0f, -1.0f, 1.0f,\\n -1.0f, -1.0f, 1.0f,\\n -1.0f, -1.0f, -1.0f,\\n };\\n // R, G, B, A\\n mCubeColourData = new float[]\\n {\\n // Front face\\n 1.0f, 0.0f, 0.0f, 1.0f,\\n 1.0f, 0.0f, 0.0f, 1.0f,\\n 1.0f, 0.0f, 0.0f, 1.0f,\\n 1.0f, 0.0f, 0.0f, 1.0f,\\n 1.0f, 0.0f, 0.0f, 1.0f,\\n 1.0f, 0.0f, 0.0f, 1.0f,\\n // Right face\\n 0.0f, 1.0f, 0.0f, 1.0f,\\n 0.0f, 1.0f, 0.0f, 1.0f,\\n 0.0f, 1.0f, 0.0f, 1.0f,\\n 0.0f, 1.0f, 0.0f, 1.0f,\\n 0.0f, 1.0f, 0.0f, 1.0f,\\n 0.0f, 1.0f, 0.0f, 1.0f,\\n // Back face\\n 0.0f, 0.0f, 1.0f, 1.0f,\\n 0.0f, 0.0f, 1.0f, 1.0f,\\n 0.0f, 0.0f, 1.0f, 1.0f,\\n 0.0f, 0.0f, 1.0f, 1.0f,\\n 0.0f, 0.0f, 1.0f, 1.0f,\\n 0.0f, 0.0f, 1.0f, 1.0f,\\n // Left face\\n 1.0f, 1.0f, 0.0f, 1.0f,\\n 1.0f, 1.0f, 0.0f, 1.0f,\\n 1.0f, 1.0f, 0.0f, 1.0f,\\n 1.0f, 1.0f, 0.0f, 1.0f,\\n 1.0f, 1.0f, 0.0f, 1.0f,\\n 1.0f, 1.0f, 0.0f, 1.0f,\\n // Top face\\n 0.0f, 1.0f, 1.0f, 1.0f,\\n 0.0f, 1.0f, 1.0f, 1.0f,\\n 0.0f, 1.0f, 1.0f, 1.0f,\\n 0.0f, 1.0f, 1.0f, 1.0f,\\n 0.0f, 1.0f, 1.0f, 1.0f,\\n 0.0f, 1.0f, 1.0f, 1.0f,\\n // Bottom face\\n 1.0f, 0.0f, 1.0f, 1.0f,\\n 1.0f, 0.0f, 1.0f, 1.0f,\\n 1.0f, 0.0f, 1.0f, 1.0f,\\n 1.0f, 0.0f, 1.0f, 1.0f,\\n 1.0f, 0.0f, 1.0f, 1.0f,\\n 1.0f, 0.0f, 1.0f, 1.0f\\n };\\n // X, Y, Z\\n mCubeNormalData = new float[]\\n {\\n // Front face\\n 0.0f, 0.0f, 1.0f,\\n 0.0f, 0.0f, 1.0f,\\n 0.0f, 0.0f, 1.0f,\\n 0.0f, 0.0f, 1.0f,\\n 0.0f, 0.0f, 1.0f,\\n 0.0f, 0.0f, 1.0f,\\n // Right face\\n 1.0f, 0.0f, 0.0f,\\n 1.0f, 0.0f, 0.0f,\\n 1.0f, 0.0f, 0.0f,\\n 1.0f, 0.0f, 0.0f,\\n 1.0f, 0.0f, 0.0f,\\n 1.0f, 0.0f, 0.0f,\\n // Back face\\n 0.0f, 0.0f, -1.0f,\\n 0.0f, 0.0f, -1.0f,\\n 0.0f, 0.0f, -1.0f,\\n 0.0f, 0.0f, -1.0f,\\n 0.0f, 0.0f, -1.0f,\\n 0.0f, 0.0f, -1.0f,\\n // Left face\\n -1.0f, 0.0f, 0.0f,\\n -1.0f, 0.0f, 0.0f,\\n -1.0f, 0.0f, 0.0f,\\n -1.0f, 0.0f, 0.0f,\\n -1.0f, 0.0f, 0.0f,\\n -1.0f, 0.0f, 0.0f,\\n // Top face\\n 0.0f, 1.0f, 0.0f,\\n 0.0f, 1.0f, 0.0f,\\n 0.0f, 1.0f, 0.0f,\\n 0.0f, 1.0f, 0.0f,\\n 0.0f, 1.0f, 0.0f,\\n 0.0f, 1.0f, 0.0f,\\n // Bottom face\\n 0.0f, -1.0f, 0.0f,\\n 0.0f, -1.0f, 0.0f,\\n 0.0f, -1.0f, 0.0f,\\n 0.0f, -1.0f, 0.0f,\\n 0.0f, -1.0f, 0.0f,\\n 0.0f, -1.0f, 0.0f\\n };\\n // X, Y\\n // Texture coordinate data.\\n mCubeTextureCoordinateData = new float[]\\n {\\n // Front face\\n 0.0f, 0.0f,\\n 0.0f, 1.0f,\\n 1.0f, 0.0f,\\n 0.0f, 1.0f,\\n 1.0f, 1.0f,\\n 1.0f, 0.0f,\\n // Right face\\n 0.0f, 0.0f,\\n 0.0f, 1.0f,\\n 1.0f, 0.0f,\\n 0.0f, 1.0f,\\n 1.0f, 1.0f,\\n 1.0f, 0.0f,\\n // Back face\\n 0.0f, 0.0f,\\n 0.0f, 1.0f,\\n 1.0f, 0.0f,\\n 0.0f, 1.0f,\\n 1.0f, 1.0f,\\n 1.0f, 0.0f,\\n // Left face\\n 0.0f, 0.0f,\\n 0.0f, 1.0f,\\n 1.0f, 0.0f,\\n 0.0f, 1.0f,\\n 1.0f, 1.0f,\\n 1.0f, 0.0f,\\n // Top face\\n 0.0f, 0.0f,\\n 0.0f, 1.0f,\\n 1.0f, 0.0f,\\n 0.0f, 1.0f,\\n 1.0f, 1.0f,\\n 1.0f, 0.0f,\\n // Bottom face\\n 0.0f, 0.0f,\\n 0.0f, 1.0f,\\n 1.0f, 0.0f,\\n 0.0f, 1.0f,\\n 1.0f, 1.0f,\\n 1.0f, 0.0f\\n };\\n // Initialize the buffers.\\n mCubeVertices = ByteBuffer.allocateDirect(mCubeVertexData.length * 4)\\n .order(ByteOrder.nativeOrder()).asFloatBuffer();\\n mCubeVertices.put(mCubeVertexData).position(0);\\n mCubeColours = ByteBuffer.allocateDirect(mCubeColourData.length * 4)\\n .order(ByteOrder.nativeOrder()).asFloatBuffer();\\n mCubeColours.put(mCubeColourData).position(0);\\n mCubeNormals = ByteBuffer.allocateDirect(mCubeNormalData.length * 4)\\n .order(ByteOrder.nativeOrder()).asFloatBuffer();\\n mCubeNormals.put(mCubeNormalData).position(0);\\n mCubeTextureCoordinates = ByteBuffer.allocateDirect(mCubeTextureCoordinateData.length * 4)\\n .order(ByteOrder.nativeOrder()).asFloatBuffer();\\n mCubeTextureCoordinates.put(mCubeTextureCoordinateData).position(0);\\n Matrix.setIdentityM(mModelMatrix, 0);\\n }\",\n \"public SoCubeWithoutTop()\\n//\\n////////////////////////////////////////////////////////////////////////\\n{\\n nodeHeader.SO_NODE_CONSTRUCTOR();\\n\\n nodeHeader.SO_NODE_ADD_SFIELD(width,\\\"width\\\", (2.0f));\\n nodeHeader.SO_NODE_ADD_SFIELD(height,\\\"height\\\", (2.0f));\\n nodeHeader.SO_NODE_ADD_SFIELD(depth,\\\"depth\\\", (2.0f));\\n\\n isBuiltIn = true;\\n\\n if (nodeHeader.SO_NODE_IS_FIRST_INSTANCE()) {\\n // Initialize corner coordinate values\\n coords[0].setValue(-1.0f, 1.0f, -1.0f); // Left Top Back\\n coords[1].setValue( 1.0f, 1.0f, -1.0f); // Right Top Back\\n coords[2].setValue(-1.0f, -1.0f, -1.0f); // Left Bottom Back\\n coords[3].setValue( 1.0f, -1.0f, -1.0f); // Right Bottom Back\\n coords[4].setValue(-1.0f, 1.0f, 1.0f); // Left Top Front\\n coords[5].setValue( 1.0f, 1.0f, 1.0f); // Right Top Front\\n coords[6].setValue(-1.0f, -1.0f, 1.0f); // Left Bottom Front\\n coords[7].setValue( 1.0f, -1.0f, 1.0f); // Right Bottom Front\\n\\n // Initialize face vertices to point into coords. The order of\\n // vertices around the faces is chosen so that the texture\\n // coordinates match up: texture coord (0,0) is at the first\\n // vertex and (1,1) is at the third. The vertices obey the\\n // right-hand rule for each face.\\n verts[1][2] = verts[2][3] = verts[4][3] = coords[0];\\n verts[1][3] = verts[3][2] = verts[4][2] = coords[1];\\n verts[1][1] = verts[2][0] = verts[5][0] = coords[2];\\n verts[1][0] = verts[3][1] = verts[5][1] = coords[3];\\n verts[0][3] = verts[2][2] = verts[4][0] = coords[4];\\n verts[0][2] = verts[3][3] = verts[4][1] = coords[5];\\n verts[0][0] = verts[2][1] = verts[5][3] = coords[6];\\n verts[0][1] = verts[3][0] = verts[5][2] = coords[7];\\n\\n // Initialize texture coordinates. These are for the 4 corners of\\n // each face, starting at the lower left corner\\n texCoords[0].setValue(0.0f, 0.0f);\\n texCoords[1].setValue(1.0f, 0.0f);\\n texCoords[2].setValue(1.0f, 1.0f);\\n texCoords[3].setValue(0.0f, 1.0f);\\n\\n // Initialize face normals\\n normals[0].setValue( 0.0f, 0.0f, 1.0f); // Front\\n normals[1].setValue( 0.0f, 0.0f, -1.0f); // Back\\n normals[2].setValue(-1.0f, 0.0f, 0.0f); // Left\\n normals[3].setValue( 1.0f, 0.0f, 0.0f); // Right\\n normals[4].setValue( 0.0f, 1.0f, 0.0f); // Top\\n normals[5].setValue( 0.0f, -1.0f, 0.0f); // Bottom\\n\\n }\\n}\",\n \"void drawSphere(GL2 gl,GLU glu, double r, int lats, int longs) {\\n\\n\\n\\n GLUquadric qobj = glu.gluNewQuadric();\\n\\n gl.glColor4f(0.0f, 0.0f, 1.0f,0.01f);\\n glu.gluQuadricDrawStyle(qobj, GLU.GLU_LINE);\\n glu.gluQuadricNormals(qobj, GLU.GLU_SMOOTH);\\n\\n glu.gluSphere(qobj, r, 70, 70);\\n\\n /*\\n int i, j;\\n for(i = 0; i <= lats; i++) {\\n float lat0 = (float) (Math.PI * (-0.5 + (double) (i - 1) / lats));\\n float z0 = (float) (Math.sin(lat0));\\n float zr0 = (float) (Math.cos(lat0));\\n\\n float lat1 = (float) (Math.PI * (-0.5 + (double) i / lats));\\n float z1 = (float) (Math.sin(lat1));\\n float zr1 = (float) (Math.expm1(lat1));\\n\\n gl.glBegin(GL_LINE_STRIP);\\n gl.glColor3f(0.0f, 1.0f, 1.0f);\\n for(j = 0; j <= longs; j++) {\\n float lng = (float) (2. * Math.PI * (double) (j - 1) / longs);\\n float x = (float) (r*Math.cos(lng));\\n float y = (float) (r*Math.sin(lng));\\n\\n\\n\\n gl.glNormal3f(x * z0, y * z0,(float)r* zr0);\\n gl.glVertex3f(x * z0, y * z0, (float) r*zr0);\\n //gl.glNormal3f(x * zr1, y * zr1, (float) r*z1);\\n //gl.glVertex3f(x * zr1, y * zr1, (float)r*z1);\\n }\\n gl.glEnd();\\n }\\n */\\n }\",\n \"public double getCylinderBaseArea();\",\n \"@Override\\r\\n\\tprotected void initShape() {\\n\\t\\tgetPositions().putAll(createSymmetricLines(0, 1.5, .5, 1.1, WingPart.OUTER_LEFT, WingPart.OUTER_RIGHT));\\r\\n\\t\\t//->upper corner\\r\\n\\t\\tgetPositions().putAll(createSymmetricLines(.5, 1.1, 1, .7, WingPart.OUTER_LEFT, WingPart.OUTER_RIGHT));\\r\\n\\t\\t//-> lower outer corner\\r\\n\\t\\tgetPositions().putAll(createSymmetricLines(1, .7, 1.1, .3, WingPart.OUTER_LEFT, WingPart.OUTER_RIGHT));\\r\\n\\t\\t//-> lower inner corner\\r\\n\\t\\tgetPositions().putAll(createSymmetricLines(1.1, .3, .7, .25, WingPart.OUTER_LEFT, WingPart.OUTER_RIGHT));\\r\\n\\t\\t//-> middle\\r\\n\\t\\tgetPositions().putAll(createSymmetricLines(.7, .25, .2, 1.35, WingPart.OUTER_LEFT, WingPart.OUTER_RIGHT));\\r\\n\\t\\t//inner\\r\\n\\t\\tgetPositions().putAll(createSymmetricLines(1, .5, .55, 0.95, WingPart.INNER_LEFT, WingPart.INNER_RIGHT));\\r\\n\\t\\tgetPositions().putAll(createSymmetricLines(0.8, .4, .55, 0.95, WingPart.INNER_LEFT, WingPart.INNER_RIGHT));\\r\\n\\t\\tgetPositions().putAll(createSymmetricPoints(0.9, .5, WingPart.INNER_LEFT, WingPart.INNER_RIGHT));\\r\\n\\r\\n//\\t\\tgetPositions().putAll(fill(WingPart.OUTER_RIGHT, WingPart.INNER_RIGHT));\\r\\n//\\t\\tgetPositions().putAll(fill(WingPart.OUTER_LEFT, WingPart.INNER_LEFT));\\r\\n\\t}\",\n \"public static String buildCylinder(String controlPoints, String id, \\n String name, String description, String lineColor, String fillColor, KmlOptions.AltitudeMode altitudeMode, \\n SymbolModifiers attributes) {\\n StringBuilder output = new StringBuilder(); \\n String pointArrayStringList = \\\"\\\";\\n\\n // variables for the cylinder position\\n double pivotx = 0.0D;\\n double pivoty = 0.0D;\\n\\n try { \\n \\n // Get the points of the icons. For the cylinder we need only\\n // one point. Ignore any more than the first point.\\n String[] latlons = controlPoints.split(\\\" \\\");\\n\\n if (latlons.length > 0) {\\n String[] pivot = latlons[0].split(\\\",\\\");\\n\\n if (pivot.length >= 2) {\\n pivotx = Double.parseDouble(pivot[0]);\\n pivoty = Double.parseDouble(pivot[1]);\\n } else {\\n throw new NumberFormatException();\\n }\\n } else {\\n // throw an illegal number of points exception\\n throw new InvalidNumberOfPointsException();\\n }\\n \\n // Build the cylinder\\n pointArrayStringList = XsltCoordinateWrapper.getCircleKml(pivotx,\\n pivoty, id, name, description, lineColor, fillColor, altitudeMode,\\n attributes.AM_DISTANCE.get(0),\\n attributes.X_ALTITUDE_DEPTH.get(0),\\n attributes.X_ALTITUDE_DEPTH.get(1)); \\n } catch (Exception e) {\\n pointArrayStringList = \\\"\\\"; \\n }\\n\\n return pointArrayStringList;\\n\\n }\",\n \"@Override\\n public void paintComponent(Graphics g) {\\n super.paintComponent(g);\\n\\n if (bdhcHandler != null) {\\n int[] slopes = bdhcHandler.getSelectedPlate().getSlope();\\n float angle = (float) Math.atan2(slopes[indexSlope1], slopes[indexSlope2]);\\n\\n Graphics2D g2 = (Graphics2D) g;\\n g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING,\\n RenderingHints.VALUE_ANTIALIAS_ON);\\n\\n g.setColor(Color.magenta);\\n final int angleRadius = (radius * 2) / 3;\\n final int angleOffset = size / 2 - angleRadius;\\n g2.setStroke(new BasicStroke(2));\\n g.drawArc(angleOffset, angleOffset, 2 * angleRadius, 2 * angleRadius, 0, (int) (-(angle * 180) / Math.PI));\\n\\n g2.setStroke(new BasicStroke(2));\\n if (frontView) {\\n g.setColor(Color.red);\\n g.drawLine(size / 2, size / 2, size, size / 2);\\n g.setColor(Color.blue);\\n g.drawLine(size / 2, size / 2, size / 2, 0);\\n } else {\\n g.setColor(Color.green);\\n //g.drawLine(size / 2, size / 2, size, size / 2);\\n g.drawLine(size / 2, size / 2, size, size / 2);\\n g.setColor(Color.blue);\\n g.drawLine(size / 2, size / 2, size / 2, 0);\\n }\\n\\n int circleOffset = size / 2 - radius;\\n g.setColor(Color.black);\\n g2.setStroke(new BasicStroke(1));\\n g.drawOval(circleOffset, circleOffset, radius * 2, radius * 2);\\n\\n int x = (int) (Math.cos(angle) * radius);\\n int y = (int) (Math.sin(angle) * radius);\\n int lineOffset = size / 2;\\n g.setColor(Color.orange);\\n g2.setStroke(new BasicStroke(3));\\n g.drawLine(lineOffset - x, lineOffset - y, lineOffset + x, lineOffset + y);\\n\\n }\\n\\n }\",\n \"private List createSkeletonOfDegree (int degree1, int degree2) {\\n List skeleton = new ArrayList();\\n \\n if (degree1 < 0 || degree2 < 0) { return skeleton; }\\n int totalDegree = degree1 + degree2;\\n for (int i = 0; i <= totalDegree; ++i) {\\n skeleton.add(0.0);\\n }\\n return skeleton;\\n }\",\n \"public static double volumeOfCylinder(double r, double h) {\\n double v = Math.PI * Math.pow(r, 2) * h;\\n v = (double) Math.round(v * 100) / 100;\\n return v;\\n }\",\n \"public void drawPolygon (int xC, int yC, int xP, int yP,int ribs, Graphics g){\\r\\n \\r\\n \\tint n = ribs; \\r\\n \\t//delta keep the the original delta , this size of delta will increase in delta size each time.\\r\\n \\tdouble delta = (2* Math.PI)/ n;\\r\\n \\tdouble deltaTemp = delta;\\r\\n \\t//List of Points that I keep during n rotation.\\r\\n \\tList points; \\r\\n \\tfloat x,y,newX,newY;\\r\\n \\t//First Sliding\\r\\n \\tx = xP - xC;\\r\\n \\ty = yP - yC;\\r\\n \\tnewX = x; \\t\\r\\n \\tnewY = y; \\t\\r\\n \\tList vertexs = new ArrayList();\\r\\n \\t//Follow delta angle rotation n times and write a list of vertices to vertexs list.\\r\\n \\tfor (int i = 0; i < n ; i++)\\r\\n \\t{\\r\\n \\t\\tnewX = (int) ((x*Math.cos(delta) - y*Math.sin(delta)));\\r\\n \\t\\tnewY = (int) ((x*Math.sin(delta) + y*Math.cos(delta))); \\r\\n \\t\\tvertexs.add(new Point(Math.round(newX),Math.round(newY))); \\t\\r\\n \\t\\tSystem.out.println(vertexs.get(i).x+\\\",\\\"+vertexs.get(i).y);\\r\\n \\t\\tdelta = delta + deltaTemp;\\r\\n \\t}\\r\\n \\t//Sliding back\\r\\n \\tfor (int i = 0; i < vertexs.size(); i++ ){\\r\\n \\t\\tvertexs.get(i).x = (int) (vertexs.get(i).getX() + xC);\\r\\n \\t\\tvertexs.get(i).y = (int) (vertexs.get(i).getY() + yC);\\r\\n \\t\\tg.drawRect(vertexs.get(i).x, vertexs.get(i).y ,1,1);\\r\\n \\t}\\r\\n \\t//draw line between the list of the points we got.\\r\\n \\tfor (int z = 0 ; z < vertexs.size(); z++){\\r\\n \\t\\tif (z == vertexs.size()-1)\\r\\n \\t\\t\\tdrawLine((int) Math.round(vertexs.get(z).getX()), (int)(vertexs.get(z).getY()),(int)(vertexs.get(0).getX()), (int)(vertexs.get(0).getY()),g);\\r\\n \\t\\telse\\r\\n \\t\\t\\tdrawLine((int)(vertexs.get(z).getX()), (int)(vertexs.get(z).getY()),(int)(vertexs.get(z+1).getX()), (int)(vertexs.get(z+1).getY()),g);\\r\\n\\r\\n \\t\\t}\\r\\n \\t\\r\\n }\",\n \"Cube(int l, int b, int h)\\r\\n\\t{\\r\\n\\t\\t//System.out.println(\\\"We are in constructor\\\");\\r\\n\\t\\tlength=l;\\r\\n\\t\\tbredth=b;\\r\\n\\t\\theight=h;\\r\\n\\t}\",\n \"public static void main(String[] args) throws FileNotFoundException\\n {\\n File file = new File(System.getProperty(\\\"user.home\\\") + \\\"/Desktop\\\", \\\"lion.off\\\");\\n Scanner s = new Scanner(file);\\n s.nextLine(); // Skip first line of context\\n\\n // Create result file(mesh2C.off)\\n try { fileManager.CreateResultFile(); }\\n catch(IOException exc) { System.out.println(\\\"Error: \\\" + exc.getMessage()); }\\n \\n // Initializing PrintWriter instance for writing data to result file\\n PrintWriter pw = new PrintWriter(System.getProperty(\\\"user.home\\\") + \\\"/Desktop/mesh2C.off\\\");\\n pw.println(\\\"OFF\\\"); // Write first line to mesh2C.off\\n\\n // Get number of vertices which lion.off has\\n String str_num_of_vertices = s.next();\\n String str_num_of_faces = s.next();\\n int num_of_vertices = Integer.parseInt(str_num_of_vertices);\\n int num_of_faces = Integer.parseInt(str_num_of_faces);\\n pw.println(Integer.toString(num_of_vertices + 8) + \\\" \\\" + Integer.toString(num_of_faces + 6) + s.nextLine());\\n\\n // Extract max and min value of each axis(X, Y, Z) separately\\n double minX = 0, maxX = 0;\\n double minY = 0, maxY = 0;\\n double minZ = 0, maxZ = 0;\\n\\n for(int i = 0; i < num_of_vertices; i++)\\n {\\n double x = Double.parseDouble(s.next());\\n if(x < minX) { minX = x; }\\n if(x > maxX) { maxX = x; }\\n double y = Double.parseDouble(s.next());\\n if(y < minY) { minY = y; }\\n if(y > maxY) { maxY = y; }\\n double z = Double.parseDouble(s.next());\\n if(z < minZ) { minZ = z; }\\n if(z > maxZ) { maxZ = z; }\\n\\n String tmp = Double.toString(x) + \\\" \\\" + Double.toString(y) + \\\" \\\" + Double.toString(z);\\n pw.println(tmp); \\n }\\n\\n // Calculate and create String arrays for Vertices and faces\\n String vStr[] = new String[8];\\n String fStr[] = new String[6];\\n\\n vStr[0] = Double.toString(minX) + \\\" \\\" + Double.toString(maxY) + \\\" \\\" + Double.toString(maxZ);\\n vStr[1] = Double.toString(minX) + \\\" \\\" + Double.toString(minY) + \\\" \\\" + Double.toString(maxZ);\\n vStr[2] = Double.toString(maxX) + \\\" \\\" + Double.toString(minY) + \\\" \\\" + Double.toString(maxZ);\\n vStr[3] = Double.toString(maxX) + \\\" \\\" + Double.toString(maxY) + \\\" \\\" + Double.toString(maxZ);\\n vStr[4] = Double.toString(minX) + \\\" \\\" + Double.toString(maxY) + \\\" \\\" + Double.toString(minZ);\\n vStr[5] = Double.toString(minX) + \\\" \\\" + Double.toString(minY) + \\\" \\\" + Double.toString(minZ);\\n vStr[6] = Double.toString(maxX) + \\\" \\\" + Double.toString(minY) + \\\" \\\" + Double.toString(minZ);\\n vStr[7] = Double.toString(maxX) + \\\" \\\" + Double.toString(maxY) + \\\" \\\" + Double.toString(minZ);\\n\\n for(int i = 0; i < 8; i++) { pw.println(vStr[i]); }\\n \\n // Calculate face list and write into result file\\n String id_quad_1 = Integer.toString(num_of_vertices);\\n String id_quad_2 = Integer.toString(num_of_vertices + 1);\\n String id_quad_3 = Integer.toString(num_of_vertices + 2);\\n String id_quad_4 = Integer.toString(num_of_vertices + 3);\\n String id_quad_5 = Integer.toString(num_of_vertices + 4);\\n String id_quad_6 = Integer.toString(num_of_vertices + 5);\\n String id_quad_7 = Integer.toString(num_of_vertices + 6);\\n String id_quad_8 = Integer.toString(num_of_vertices + 7);\\n\\n fStr[0] = \\\"4 \\\" + id_quad_1 + \\\" \\\" + id_quad_4 + \\\" \\\" + id_quad_3 + \\\" \\\" + id_quad_2;\\n fStr[1] = \\\"4 \\\" + id_quad_5 + \\\" \\\" + id_quad_6 + \\\" \\\" + id_quad_7 + \\\" \\\" + id_quad_8;\\n fStr[2] = \\\"4 \\\" + id_quad_1 + \\\" \\\" + id_quad_5 + \\\" \\\" + id_quad_8 + \\\" \\\" + id_quad_4;\\n fStr[3] = \\\"4 \\\" + id_quad_3 + \\\" \\\" + id_quad_7 + \\\" \\\" + id_quad_6 + \\\" \\\" + id_quad_2;\\n fStr[4] = \\\"4 \\\" + id_quad_2 + \\\" \\\" + id_quad_6 + \\\" \\\" + id_quad_5 + \\\" \\\" + id_quad_1;\\n fStr[5] = \\\"4 \\\" + id_quad_4 + \\\" \\\" + id_quad_8 + \\\" \\\" + id_quad_7 + \\\" \\\" + id_quad_3;\\n\\n // Copy face data from original lion.off file to result file\\n s.nextLine();\\n for(int i = 0; i < num_of_faces; i++) { pw.println(s.nextLine()); }\\n \\n // Add new face data at the bottom of result file\\n for(int i = 0; i < 6; i++) { pw.println(fStr[i]); }\\n\\n // Terminate filestream\\n s.close();\\n pw.close();\\n }\",\n \"@SuppressWarnings(\\\"unused\\\")\\r\\n private void makeSubcutaneousFat2DVOI() {\\r\\n\\r\\n // find the center of mass of the single label object in the sliceBuffer (abdomenImage)\\r\\n findAbdomenCM();\\r\\n int xcm = centerOfMass[0];\\r\\n int ycm = centerOfMass[1];\\r\\n \\r\\n VOIVector vois = abdomenImage.getVOIs();\\r\\n VOI theVOI = vois.get(0);\\r\\n\\r\\n // there should be only one VOI and one curve\\r\\n VOIContour curve = ((VOIContour)theVOI.getCurves().get(0));\\r\\n int[] xVals = new int [curve.size()];\\r\\n int[] yVals = new int [curve.size()];\\r\\n int[] zVals = new int [curve.size()];\\r\\n curve.exportArrays(xVals, yVals, zVals);\\r\\n \\r\\n int[] xValsSubcutaneousVOI = new int [curve.size()];\\r\\n int[] yValsSubcutaneousVOI = new int [curve.size()];\\r\\n \\r\\n \\r\\n // the intensity profile along a radial line for a given angle\\r\\n short[] profile;\\r\\n \\r\\n // the x, y location of all the pixels along a radial line for a given angle\\r\\n int[] xLocs;\\r\\n int[] yLocs;\\r\\n try {\\r\\n profile = new short[xDim];\\r\\n xLocs = new int[xDim];\\r\\n yLocs = new int[xDim];\\r\\n } catch (OutOfMemoryError error) {\\r\\n System.gc();\\r\\n MipavUtil.displayError(\\\"findAbdomenVOI(): Can NOT allocate profile\\\");\\r\\n return;\\r\\n }\\r\\n\\r\\n try {\\r\\n srcImage.exportData(0, sliceSize, sliceBuffer);\\r\\n } catch (IOException ex) {\\r\\n System.err.println(\\\"JCATsegmentAbdomen2D(): Error exporting data\\\");\\r\\n return;\\r\\n }\\r\\n\\r\\n\\r\\n // find a subcutaneous fat contour point for each abdominal contour point\\r\\n // we know the abdominal contour points are located at three degree increments\\r\\n double angleRad;\\r\\n int count;\\r\\n int contourPointIdx = 0;\\r\\n for (int angle = 0; angle < 360; angle += angularResolution) {\\r\\n count = 0;\\r\\n int x = xcm;\\r\\n int y = ycm;\\r\\n int yOffset = y * xDim;\\r\\n double scaleFactor; // reduces the number of trig operations that must be performed\\r\\n \\r\\n angleRad = Math.PI * angle / 180.0;\\r\\n if (angle > 315 || angle <= 45) {\\r\\n // increment x each step\\r\\n scaleFactor = Math.tan(angleRad);\\r\\n while (x < xVals[contourPointIdx]) {\\r\\n // store the intensity and location of each point along the radial line\\r\\n profile[count] = sliceBuffer[yOffset + x];\\r\\n xLocs[count] = x;\\r\\n yLocs[count] = y;\\r\\n count++;\\r\\n \\r\\n // walk out in x and compute the value of y for the given radial line\\r\\n x++;\\r\\n y = ycm - (int)((x - xcm) * scaleFactor);\\r\\n yOffset = y * xDim;\\r\\n }\\r\\n\\r\\n // profile contains all the source image intensity values along the line from\\r\\n // the center-of-mass to the abdomen VOI point\\r\\n // Find where the subcutaneous fat ends and the muscle starts\\r\\n \\r\\n // start at the end of the profile array since its order is from the\\r\\n // center-of-mass to the abdomen voi point\\r\\n \\r\\n int idx = count - 5; // skip over the skin\\r\\n while (idx >= 0 && profile[idx] < muscleThresholdHU && profile[idx] > airThresholdHU) {\\r\\n idx--;\\r\\n }\\r\\n if (idx <= 0) {\\r\\n MipavUtil.displayError(\\\"findAbdomenVOI(): Can NOT find visceral cavity in the intensity profile\\\");\\r\\n break;\\r\\n }\\r\\n xValsSubcutaneousVOI[contourPointIdx] = xLocs[idx];\\r\\n yValsSubcutaneousVOI[contourPointIdx] = yLocs[idx];\\r\\n \\r\\n } else if (angle > 45 && angle <= 135) {\\r\\n // decrement y each step\\r\\n scaleFactor = (Math.tan((Math.PI / 2.0) - angleRad));\\r\\n while (y > yVals[contourPointIdx]) {\\r\\n // store the intensity and location of each point along the radial line\\r\\n profile[count] = sliceBuffer[yOffset + x];\\r\\n xLocs[count] = x;\\r\\n yLocs[count] = y;\\r\\n count++;\\r\\n \\r\\n // walk to the top of the image and compute values of x for the given radial line\\r\\n y--;\\r\\n x = xcm + (int)((ycm - y) * scaleFactor);\\r\\n yOffset = y * xDim;\\r\\n }\\r\\n \\r\\n // profile contains all the source image intensity values along the line from\\r\\n // the center-of-mass to the newly computed abdomen VOI point\\r\\n // Find where the subcutaneous fat ends\\r\\n int idx = count - 5; // skip over the skin\\r\\n while (idx >= 0 && profile[idx] < muscleThresholdHU&& profile[idx] > airThresholdHU) {\\r\\n idx--;\\r\\n }\\r\\n if (idx == 0) {\\r\\n MipavUtil.displayError(\\\"findAbdomenVOI(): Can NOT find visceral cavity in the intensity profile\\\");\\r\\n return;\\r\\n }\\r\\n xValsSubcutaneousVOI[contourPointIdx] = xLocs[idx];\\r\\n yValsSubcutaneousVOI[contourPointIdx] = yLocs[idx];\\r\\n \\r\\n } else if (angle > 135 && angle <= 225) {\\r\\n // decrement x each step\\r\\n scaleFactor = Math.tan(Math.PI - angleRad);\\r\\n while (x > xVals[contourPointIdx]) {\\r\\n // store the intensity and location of each point along the radial line\\r\\n profile[count] = sliceBuffer[yOffset + x];\\r\\n xLocs[count] = x;\\r\\n yLocs[count] = y;\\r\\n count++;\\r\\n \\r\\n x--;\\r\\n y = ycm - (int)((xcm - x) * scaleFactor);\\r\\n yOffset = y * xDim;\\r\\n }\\r\\n \\r\\n // profile contains all the source image intensity values along the line from\\r\\n // the center-of-mass to the newly computed abdomen VOI point\\r\\n // Find where the subcutaneous fat ends\\r\\n int idx = count - 5; // skip over the skin\\r\\n while (idx >= 0 && profile[idx] < muscleThresholdHU&& profile[idx] > airThresholdHU) {\\r\\n idx--;\\r\\n }\\r\\n if (idx == 0) {\\r\\n MipavUtil.displayError(\\\"findAbdomenVOI(): Can NOT find visceral cavity in the intensity profile\\\");\\r\\n return;\\r\\n }\\r\\n xValsSubcutaneousVOI[contourPointIdx] = xLocs[idx];\\r\\n yValsSubcutaneousVOI[contourPointIdx] = yLocs[idx];\\r\\n \\r\\n } else if (angle > 225 && angle <= 315) {\\r\\n // increment y each step\\r\\n scaleFactor = Math.tan((3.0 * Math.PI / 2.0) - angleRad);\\r\\n while (y < yVals[contourPointIdx]) {\\r\\n // store the intensity and location of each point along the radial line\\r\\n profile[count] = sliceBuffer[yOffset + x];\\r\\n xLocs[count] = x;\\r\\n yLocs[count] = y;\\r\\n count++;\\r\\n \\r\\n y++;\\r\\n x = xcm - (int)((y - ycm) * scaleFactor);\\r\\n yOffset = y * xDim;\\r\\n }\\r\\n \\r\\n // profile contains all the source image intensity values along the line from\\r\\n // the center-of-mass to the newly computed abdomen VOI point\\r\\n // Find where the subcutaneous fat ends\\r\\n int idx = count - 5; // skip over the skin\\r\\n while (idx >= 0 && profile[idx] < muscleThresholdHU&& profile[idx] > airThresholdHU) {\\r\\n idx--;\\r\\n }\\r\\n if (idx == 0) {\\r\\n MipavUtil.displayError(\\\"findAbdomenVOI(): Can NOT find visceral cavity in the intensity profile\\\");\\r\\n return;\\r\\n }\\r\\n xValsSubcutaneousVOI[contourPointIdx] = xLocs[idx];\\r\\n yValsSubcutaneousVOI[contourPointIdx] = yLocs[idx];\\r\\n\\r\\n }\\r\\n \\r\\n contourPointIdx++;\\r\\n } // end for (angle = 0; ...\\r\\n\\r\\n\\r\\n // make the VOI's and add the points to them\\r\\n subcutaneousVOI = new VOI((short)0, \\\"Subcutaneous area\\\");\\r\\n subcutaneousVOI.importCurve(xValsSubcutaneousVOI, yValsSubcutaneousVOI, zVals);\\r\\n\\r\\n }\",\n \"ArrayList> generateInitVertices() {\\n ArrayList> vertices = new ArrayList>();\\n for (int x = 0; x < width; x++) {\\n ArrayList temp = new ArrayList();\\n for (int y = 0; y < height; y++) {\\n temp.add(new Vertex(x, y));\\n }\\n vertices.add(temp);\\n }\\n Random r = new Random();\\n for (ArrayList vList : vertices) {\\n for (Vertex v : vList) {\\n if (v.x != 0) {\\n v.outEdges.add(new Edge(v, vertices.get(v.x - 1).get(v.y), r.nextInt(1000)));\\n }\\n if (v.x != width - 1) {\\n v.outEdges.add(new Edge(v, vertices.get(v.x + 1).get(v.y), r.nextInt(1000)));\\n }\\n if (v.y != 0) {\\n v.outEdges.add(new Edge(v, vertices.get(v.x).get(v.y - 1), r.nextInt(1000)));\\n }\\n if (v.y != height - 1) {\\n v.outEdges.add(new Edge(v, vertices.get(v.x).get(v.y + 1), r.nextInt(1000)));\\n }\\n }\\n }\\n return vertices;\\n }\",\n \"public Astrocylinders() {\\r\\n\\t\\tsuper(CompartmentType.ASTROCYLINDERS.numParams);\\r\\n\\t}\",\n \"protected void skybox() {\\n Triple pos1, pos2, pos3, pos4, pos5, pos6, pos7, pos8, col1, col2, col3, col4;\\n\\n pos1 = new Triple(0, 0, 0);\\n pos2 = new Triple(100, 0, 0);\\n pos3 = new Triple(100, 0, 100);\\n pos4 = new Triple(0, 0, 100);\\n pos5 = new Triple(0, 100, 0);\\n pos6 = new Triple(100, 100, 0);\\n pos7 = new Triple(100, 100, 100);\\n pos8 = new Triple(0, 100, 100);\\n\\n // Front Triangles\\n frozenSoups.addTri( new Triangle(new Vertex(pos1, 0, 0),\\n new Vertex(pos2, .25, 0),\\n new Vertex(pos3, .25, 1),\\n 21 ) );\\n\\n frozenSoups.addTri( new Triangle(new Vertex(pos3, .25, 1),\\n new Vertex(pos4, 0, 1),\\n new Vertex(pos1, 0, 0),\\n 21 ) );\\n\\n // Left Triangles\\n frozenSoups.addTri( new Triangle(new Vertex(pos1, 1, 0),\\n new Vertex(pos5, .75, 0),\\n new Vertex(pos8, .75, 1),\\n 21 ) );\\n\\n frozenSoups.addTri( new Triangle(new Vertex(pos8, .75, 1),\\n new Vertex(pos4, 1, 1),\\n new Vertex(pos1, 1, 0),\\n 21 ) );\\n\\n // Right Triangles\\n frozenSoups.addTri( new Triangle(new Vertex(pos2, .25, 0),\\n new Vertex(pos6, .5, 0),\\n new Vertex(pos7, .5, 1),\\n 21 ) );\\n\\n frozenSoups.addTri( new Triangle(new Vertex(pos7, .5, 1),\\n new Vertex(pos3, .25, 1),\\n new Vertex(pos2, .25, 0),\\n 21 ) );\\n\\n // Back Triangles\\n frozenSoups.addTri( new Triangle(new Vertex(pos5, .75, 0),\\n new Vertex(pos6, .5, 0),\\n new Vertex(pos7, .5, 1),\\n 21 ) );\\n\\n frozenSoups.addTri( new Triangle(new Vertex(pos7, .5, 1),\\n new Vertex(pos8, .75, 1),\\n new Vertex(pos5, .75, 0),\\n 21 ) );\\n\\n // Top Triangles\\n// frozenSoups.addTri( new Triangle(new Vertex(pos4, 0, 0),\\n// new Vertex(pos3, 0, 1),\\n// new Vertex(pos7, 1, 1),\\n// 20 ) );\\n\\n// frozenSoups.addTri( new Triangle(new Vertex(pos7, 0, 0),\\n// new Vertex(pos8, 1, 0),\\n// new Vertex(pos4, 1, 1),\\n// 20 ) );\\n }\",\n \"public static List drawCube(Location location1, Location location2, Float density, boolean isBlock) {\\n Location loc1 = location1.clone(), loc2 = location2.clone();\\n\\n loc1.setX(Math.min(location1.getX(),location2.getX()));\\n loc1.setY(Math.min(location1.getY(),location2.getY()));\\n loc1.setZ(Math.min(location1.getZ(),location2.getZ()));\\n loc2.setX(Math.max(location1.getX(),location2.getX()));\\n loc2.setY(Math.max(location1.getY(),location2.getY()));\\n loc2.setZ(Math.max(location1.getZ(),location2.getZ()));\\n\\n if (isBlock) {\\n loc1 = loc1.getBlock().getLocation();\\n loc2 = loc2.getBlock().getLocation();\\n loc2.add(1, 1, 1);\\n }\\n\\n double deltaX = Math.abs(loc1.getX() - loc2.getX());\\n double deltaY = Math.abs(loc1.getY() - loc2.getY());\\n double deltaZ = Math.abs(loc1.getZ() - loc2.getZ());\\n\\n int dx = (int) Math.ceil(deltaX / density);\\n int dy = (int) Math.ceil(deltaY / density);\\n int dz = (int) Math.ceil(deltaZ / density);\\n\\n List collection = new ArrayList<>();\\n int[][] var1 = {{0, 0}, {1, 0}, {0, 1}, {1, 1}};\\n for (int[] i : var1) {\\n Location locx = loc1.clone().add(i[0] * deltaX, 0, i[1] * deltaZ);\\n collection.addAll(drawline(locx, locx.clone().add(0, deltaY, 0),dy));\\n\\n locx = loc1.clone().add(0, i[0] * deltaY, i[1] * deltaZ);\\n collection.addAll(drawline(locx, locx.clone().add(deltaX, 0, 0),dx));\\n\\n locx = loc1.clone().add(i[0] * deltaX, i[1] * deltaY, 0);\\n collection.addAll(drawline(locx, locx.clone().add(0, 0, deltaZ),dz));\\n }\\n return collection;\\n }\",\n \"private RadiusSector() {}\",\n \"protected Geometry buildShape(\\r\\n CSGGeometry.CSGOperator\\t\\tpOperator1\\r\\n ,\\tfloat\\t\\t\\t\\t\\t\\tpLength\\r\\n ,\\tCSGGeometry.CSGOperator\\t\\tpOperator2\\r\\n ,\\tboolean\\t\\t\\t\\t\\t\\tpRotate\\r\\n ) {\\n Material mat_csg = new Material( assetManager, \\\"Common/MatDefs/Misc/ShowNormals.j3md\\\" );\\r\\n \\t//mat_csg.getAdditionalRenderState().setFaceCullMode( FaceCullMode.Off );\\r\\n\\r\\n \\tCSGGeometry aGeometry = new CSGGeometry();\\r\\n \\taGeometry.setMaterial( mat_csg );\\r\\n\\r\\n \\tCSGShape aCube = new CSGShape( \\\"Box\\\", new Box(1,1,1) );\\r\\n \\tif ( pRotate ) aCube.rotate( 0.4f, 0.4f, 0f );\\r\\n \\taGeometry.addShape( aCube, pOperator1 );\\r\\n\\r\\n \\tCSGShape aCylinder = new CSGShape( \\\"Cylinder\\\", new Cylinder( 32, 32, 1.1f, pLength, true ) );\\r\\n \\taGeometry.addShape( aCylinder, pOperator2 );\\r\\n \\t\\r\\n \\taGeometry.regenerate();\\r\\n \\treturn( aGeometry );\\r\\n }\",\n \"public static void test1() {\\n int n1 = 100, n2 = 100, n3 = 100;\\n float v = 1.0f, d = 20.0f;\\n float[][][] paint = new float[n3][n2][n1];\\n /*\\n for (int i3=0; i3= 0.1f) {\\n // normalize direction\\n x0 = f0 / swell_height;\\n y0 = f1 / swell_height;\\n \\n float start_arrow = 0.9f * sscale;\\n float end_arrow = 1.9f * sscale;\\n float arrow_head = 0.3f * sscale;\\n x1 = (x + x0 * start_arrow);\\n y1 = (y + y0 * start_arrow);\\n x2 = (x + x0 * end_arrow);\\n y2 = (y + y0 * end_arrow);\\n \\n // draw arrow shaft\\n vx[nv] = x1;\\n vy[nv] = y1;\\n vz[nv] = z;\\n nv++;\\n vx[nv] = x2;\\n vy[nv] = y2;\\n vz[nv] = z;\\n nv++;\\n \\n mbarb[2] = x2;\\n mbarb[3] = y2;\\n \\n xd = x2 - x1;\\n yd = y2 - y1;\\n \\n x3 = x2 - 0.3f * (xd - yd);\\n y3 = y2 - 0.3f * (yd + xd);\\n x4 = x2 - 0.3f * (xd + yd);\\n y4 = y2 - 0.3f * (yd - xd);\\n \\n // draw arrow head\\n vx[nv] = x2;\\n vy[nv] = y2;\\n vz[nv] = z;\\n nv++;\\n vx[nv] = x3;\\n vy[nv] = y3;\\n vz[nv] = z;\\n nv++;\\n \\n vx[nv] = x2;\\n vy[nv] = y2;\\n vz[nv] = z;\\n nv++;\\n vx[nv] = x4;\\n vy[nv] = y4;\\n vz[nv] = z;\\n nv++;\\n \\n int shi = (int) (10.0f * (swell_height + 0.5f));\\n float shf = 0.1f * shi;\\n String sh_string = Float.toString(shf);\\n int point = sh_string.indexOf('.');\\n sh_string = sh_string.substring(0, point + 2);\\n double[] start = {x, y - 0.25 * sscale, 0.0};\\n double[] base = {0.5 * sscale, 0.0, 0.0};\\n double[] up = {0.0, 0.5 * sscale, 0.0};\\n VisADLineArray array =\\n PlotText.render_label(sh_string, start, base, up, true);\\n int nl = array.vertexCount;\\n int k = 0;\\n for (int i=0; i();\\n\\n ArrayList positions = new ArrayList();\\n double step = sector.getDeltaLatDegrees() / this.divisions;\\n\\n // Generate meridians with labels\\n double lon = sector.getMinLongitude().degrees + (this.level == 0 ? 0 : step);\\n while (lon < sector.getMaxLongitude().degrees - step / 2)\\n {\\n Angle longitude = Angle.fromDegrees(lon);\\n // Meridian\\n positions.clear();\\n positions.add(new Position(this.sector.getMinLatitude(), longitude, 0));\\n positions.add(new Position(this.sector.getMaxLatitude(), longitude, 0));\\n\\n Object polyline = createLineRenderable(positions, Polyline.LINEAR);\\n Sector sector = Sector.fromDegrees(\\n this.sector.getMinLatitude().degrees, this.sector.getMaxLatitude().degrees, lon, lon);\\n String lineType = lon == this.sector.getMinLongitude().degrees ?\\n GridElement.TYPE_LINE_WEST : GridElement.TYPE_LINE;\\n GridElement ge = new GridElement(sector, polyline, lineType);\\n ge.value = lon;\\n this.gridElements.add(ge);\\n\\n // Increase longitude\\n lon += step;\\n }\\n\\n // Generate parallels\\n double lat = this.sector.getMinLatitude().degrees + (this.level == 0 ? 0 : step);\\n while (lat < this.sector.getMaxLatitude().degrees - step / 2)\\n {\\n Angle latitude = Angle.fromDegrees(lat);\\n positions.clear();\\n positions.add(new Position(latitude, this.sector.getMinLongitude(), 0));\\n positions.add(new Position(latitude, this.sector.getMaxLongitude(), 0));\\n \\n Object polyline = createLineRenderable(positions, Polyline.LINEAR);\\n Sector sector = Sector.fromDegrees(\\n lat, lat, this.sector.getMinLongitude().degrees, this.sector.getMaxLongitude().degrees);\\n String lineType = lat == this.sector.getMinLatitude().degrees ?\\n GridElement.TYPE_LINE_SOUTH : GridElement.TYPE_LINE;\\n GridElement ge = new GridElement(sector, polyline, lineType);\\n ge.value = lat;\\n this.gridElements.add(ge);\\n\\n // Increase latitude\\n lat += step;\\n }\\n }\",\n \"public int drawV2(int x, int y, int z, int rotationX, int rotationY) {\\n\\n\\t\\t\\t\\tif (debug) {\\n\\t\\t\\t\\t\\tSystem.out.println(\\\"RotX\\\" + rotationX);\\n\\t\\t\\t\\t\\tSystem.out.println(\\\"RotY\\\" + rotationY);\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tint size = ob_size - z;\\n\\t\\t\\t\\tdouble rotationX_double = (double) rotationX; // cast rotationX as a double (must be a double to do\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t// division)\\n\\t\\t\\t\\tdouble rotation_X_rad = (rotationX_double / 180) * Math.PI; // convert rotation_X to radians\\n\\t\\t\\t\\tdouble width_double = size * (Math.cos(rotation_X_rad));\\n\\t\\t\\t\\tint width = (int) width_double;\\n\\n\\t\\t\\t\\tif (debug)\\n\\t\\t\\t\\t\\tSystem.out.println(\\\"Width: \\\" + width);\\n\\n\\t\\t\\t\\tdouble rotationY_double = (double) rotationY; // cast rotationY as a double (must be a double to do\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t// division)\\n\\t\\t\\t\\tdouble rotation_Y_rad = (rotationY_double / 180) * Math.PI; // convert rotation_Y to radians\\n\\t\\t\\t\\tdouble height_double = size * (Math.cos(rotation_Y_rad));\\n\\t\\t\\t\\tint height = (int) height_double;\\n\\n\\t\\t\\t\\tif (debug)\\n\\t\\t\\t\\t\\tSystem.out.println(\\\"height: \\\" + height);\\n\\n\\t\\t\\t\\twidth = Math.abs(width);\\n\\t\\t\\t\\theight = Math.abs(height);\\n\\n\\t\\t\\t\\tint rotate_deviation_X = size - width;\\n\\t\\t\\t\\tint rotate_deviation_Y = size - height;\\n\\n\\t\\t\\t\\tif (debug) {\\n\\t\\t\\t\\t\\tSystem.out.println(\\\"RDEVX: \\\" + rotate_deviation_X);\\n\\t\\t\\t\\t\\tSystem.out.println(\\\"RDEVY: \\\" + rotate_deviation_Y);\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tpage.drawRect(x, y, width, height); // front edges\\n\\n\\t\\t\\t\\tpage.drawRect(x + rotate_deviation_X, y - rotate_deviation_Y, width, height); // back edges\\n\\n\\t\\t\\t\\tpage.drawLine(x, y, x + (rotate_deviation_X), y - (rotate_deviation_Y)); // top left edge\\n\\t\\t\\t\\tpage.drawLine(x, y + height, x + (rotate_deviation_X), y - (rotate_deviation_Y) + height); // top right\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t// edge\\n\\n\\t\\t\\t\\tpage.drawLine(x + width, y, x + (rotate_deviation_X) + width, y - (rotate_deviation_Y)); // bottom left\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t// edge\\n\\t\\t\\t\\tpage.drawLine(x + width, y + height, x + (rotate_deviation_X) + width,\\n\\t\\t\\t\\t\\t\\ty - (rotate_deviation_Y) + height); // bottom right edge\\n\\n\\t\\t\\t\\t// ----------------------------------------\\n\\t\\t\\t\\treturn rotate_deviation_X;\\n\\t\\t\\t}\",\n \"public void makeTriangleBox(int offsetX, int offsetY, int myWidth, int myHeight, int numTriHorizontal, int numTriVertical, int collRect, float[][] verts) {\\n //Top Triangles\\n for (int i = 0; i < numTriHorizontal; i++) {\\n verts[i][0] = (i*myWidth/numTriHorizontal) + offsetX;\\n verts[i][1] = offsetY;\\n verts[i][2] = ((i+1)*(myWidth/numTriHorizontal)) + offsetX;\\n verts[i][3] = offsetY;\\n verts[i][4] = (myWidth/(2*numTriHorizontal)) + (i*myWidth/numTriHorizontal) + offsetX;\\n if(i%2==0) {\\n verts[i][5] = (float) ((Math.sqrt(3) / 2) * (myWidth / numTriHorizontal)) + offsetY;\\n } else {\\n verts[i][5] = (float)((Math.sqrt(3) / 2) * (myWidth / numTriHorizontal)) + offsetY;\\n }\\n\\n }\\n\\n //Left Triangles\\n\\n for (int i = numTriHorizontal; i < (numTriVertical + numTriHorizontal); i++) {\\n verts[i][0] = offsetX;\\n verts[i][1] = offsetY + ((i-numTriHorizontal) * (myWidth/numTriHorizontal));\\n verts[i][2] = offsetX;\\n verts[i][3] = offsetY + ((i-(numTriHorizontal-1)) * (myWidth/numTriHorizontal));\\n if(i%2==0) {\\n verts[i][4] = offsetX + (float) ((Math.sqrt(3) / 2) * (myWidth / numTriHorizontal));\\n } else {\\n verts[i][4] = offsetX + (float) ((Math.sqrt(3) / 2) * (myWidth / numTriHorizontal));\\n }\\n verts[i][5] = offsetY + ((i-numTriHorizontal) * (myWidth/numTriHorizontal)) + myWidth/(2*numTriHorizontal);\\n\\n }\\n\\n\\n //Right Triangles\\n for(int i=numTriVertical+numTriHorizontal; i<(2*numTriVertical)+numTriHorizontal; i++) {\\n verts[i][0] = width-offsetX;\\n verts[i][1] = offsetY + ((i-(numTriVertical+numTriHorizontal)) * (myWidth/numTriHorizontal));\\n verts[i][2] = width-offsetX;\\n verts[i][3] = offsetY + ((i-(numTriVertical+(numTriHorizontal-1))) * (myWidth/numTriHorizontal));\\n if(i%2==0) {\\n verts[i][4] = width-(offsetX + (float) ((Math.sqrt(3) / 2) * (myWidth / numTriHorizontal)));\\n } else {\\n verts[i][4] = width-(offsetX + (float) ((Math.sqrt(3) / 2) * (myWidth / numTriHorizontal)));\\n }\\n verts[i][5] = offsetY + ((i-(numTriVertical+numTriHorizontal)) * (myWidth/numTriHorizontal)) + myWidth/(2*numTriHorizontal);\\n\\n }\\n\\n //Bottom Triangles\\n for(int i=(2*numTriVertical)+numTriHorizontal; i<(2*numTriVertical)+(2*numTriHorizontal); i++) {\\n verts[i][0] = ((i-((2*numTriVertical)+numTriHorizontal))*myWidth/numTriHorizontal) + offsetX;\\n verts[i][1] = (height-100) - offsetY;\\n verts[i][2] = ((i-((2*numTriVertical)+numTriHorizontal) +1)*(myWidth/numTriHorizontal)) + offsetX;\\n verts[i][3] = (height-100) - offsetY;\\n verts[i][4] = (myWidth/(2*numTriHorizontal)) + ((i-((2*numTriVertical)+numTriHorizontal))*myWidth/numTriHorizontal) + offsetX;\\n if(i%2==0) {\\n verts[i][5] = (float)((height-100) - ( ((Math.sqrt(3) / 2) * (myWidth / numTriHorizontal)) + offsetY));\\n } else {\\n verts[i][5] = (float)((height-100) - ( ((Math.sqrt(3) / 2) * (myWidth / numTriHorizontal)) + offsetY));\\n }\\n\\n }\\n\\n }\",\n \"public void makeSatellite(float radius, int radialDivisions,\\n\\t\\t\\tint heightDivisions) {\\n\\t\\tif (radialDivisions < 3)\\n\\t\\t\\tradialDivisions = 3;\\n\\n\\t\\tif (heightDivisions < 1)\\n\\t\\t\\theightDivisions = 1;\\n\\n\\t\\tif (heightDivisions > 65)\\n\\t\\t\\theightDivisions = 65;\\n\\n\\t\\tif (radialDivisions > 65)\\n\\t\\t\\tradialDivisions = 65;\\n\\t//\\tSystem.out.println(radialDivisions + \\\" \\\" + heightDivisions);\\n\\n\\t\\tfloat theta = (float) (2 * Math.PI / radialDivisions);\\n\\t\\tfloat refy = 0.5f;\\n\\t\\tfloat nxty = 1f / heightDivisions;\\n\\n\\t\\t// coordinates for the triangle formation\\n\\t\\tfloat x1 = 0;\\n\\t\\tfloat y1 = 0;\\n\\t\\tfloat z1 = 0;\\n\\t\\tfloat x2 = 0;\\n\\t\\tfloat y2 = 0;\\n\\t\\tfloat z2 = 0;\\n\\t\\tfloat x3 = 0;\\n\\t\\tfloat y3 = 0;\\n\\t\\tfloat z3 = 0;\\n\\t\\tfor (int rD = 0; rD < radialDivisions; rD++) {\\n\\t\\t\\t//defining coordinates of first point\\n\\t\\t\\tx1 = 0f;\\n\\t\\t\\ty1 = refy;\\n\\t\\t\\tz1 = 0f;\\n\\t\\t\\t//defining coordinates of second point\\n\\t\\t\\tx2 = (float) (radius * Math.cos(theta * rD));\\n\\t\\t\\ty2 = y1;\\n\\t\\t\\tz2 = -(float) (radius * Math.sin(theta * rD));\\n\\t\\t\\t//defining coordinates of third point\\n\\t\\t\\tx3 = (float) (radius * Math.cos(theta * (rD + 1)));\\n\\t\\t\\ty3 = y1;\\n\\t\\t\\tz3 = -(float) (radius * Math.sin(theta * (rD + 1)));\\n\\n\\t\\t\\t// tesselation for bottom circle\\n\\t\\t\\taddTriangle(x1, y1, z1, 0.0f, 0.0f, x2, y2, z2, 0.0f, 0.0f, x3, y3, z3, 0.0f, 0.0f);\\n\\n\\t\\t\\ty1 = -y1;\\n\\n\\t\\t\\tx2 = (float) (radius * Math.cos(theta * (rD + 1)));\\n\\t\\t\\ty2 = y1;\\n\\t\\t\\tz2 = -(float) (radius * Math.sin(theta * (rD + 1)));\\n\\n\\t\\t\\tx3 = (float) (radius * Math.cos(theta * (rD)));\\n\\t\\t\\ty3 = y1;\\n\\t\\t\\tz3 = -(float) (radius * Math.sin(theta * (rD)));\\n\\n\\t\\t\\t// tesselation for top circle\\n\\t\\t\\taddTriangle(x1, y1, z1, 0.0f, 0.0f, x2, y2, z2, 0.0f, 0.0f, x3, y3, z3, 0.0f, 0.0f);\\n\\n\\t\\t\\ttesselationForCylinder(radius, heightDivisions, theta, refy, nxty,\\n\\t\\t\\t\\t\\trD);\\n\\t\\t}\\n\\t\\t\\n\\t}\",\n \"private void paint(int sideLength) {\\n\\n float fac = randomStart;\\n while (sideLength >= 2) {\\n\\n for (int py = 0; py < _height; py += sideLength) {\\n for (int px = 0; px < _width; px += sideLength) {\\n // fetch corner colors\\n float c1 = mono[repeat(px, py, _width, _height)];\\n float c3 = mono[repeat(px + sideLength, py, _width, _height)];\\n float c7 = mono[repeat(px, py + sideLength, _width, _height)];\\n float c9 = mono[repeat(px + sideLength, py + sideLength, _width,\\n _height)];\\n\\n int shortX = px / sideLength; \\n int shortY = py / sideLength; \\n \\n \\n float c2 = (c1 + c3) / 2 + calcFac(fac, shortX, shortY);\\n float c4 = (c1 + c7) / 2 + calcFac(fac, shortX, shortY);\\n float c5 = (c1 + c3 + c7 + c9) / 4 + calcFac(fac, shortX, shortY);\\n\\n mono[repeat(px + sideLength / 2, py, _width, _height)] = c2;\\n mono[repeat(px, py + sideLength / 2, _width, _height)] = c4;\\n mono[repeat(px + sideLength / 2, py + sideLength / 2, _width, _height)] = c5;\\n }\\n }\\n\\n fac = fac * randomFactor + randomSummand;\\n\\n sideLength /= 2;\\n }\\n }\",\n \"private static void breadcrumbArrow(int width, int height, int indent, int c1, int c2) {\\n\\n\\t\\tdouble x0 = 0, y0 = height / 2d;\\n\\t\\tdouble x1 = indent, y1 = 0;\\n\\t\\tdouble x2 = indent, y2 = height / 2d;\\n\\t\\tdouble x3 = indent, y3 = height;\\n\\t\\tdouble x4 = width, y4 = 0;\\n\\t\\tdouble x5 = width, y5 = height / 2d;\\n\\t\\tdouble x6 = width, y6 = height;\\n\\t\\tdouble x7 = indent + width, y7 = 0;\\n\\t\\tdouble x8 = indent + width, y8 = height;\\n\\n\\t\\tint fc1 = ColorHelper.mixAlphaColors(c1, c2, 0);\\n\\t\\tint fc2 = ColorHelper.mixAlphaColors(c1, c2, (indent)/(width + 2f * indent));\\n\\t\\tint fc3 = ColorHelper.mixAlphaColors(c1, c2, (indent + width)/(width + 2f * indent));\\n\\t\\tint fc4 = ColorHelper.mixAlphaColors(c1, c2, 1);\\n\\n\\t\\tRenderSystem.disableTexture();\\n\\t\\tRenderSystem.enableBlend();\\n\\t\\tRenderSystem.disableAlphaTest();\\n\\t\\tRenderSystem.defaultBlendFunc();\\n\\t\\tRenderSystem.shadeModel(GL11.GL_SMOOTH);\\n\\n\\t\\tTessellator tessellator = Tessellator.getInstance();\\n\\t\\tBufferBuilder bufferbuilder = tessellator.getBuffer();\\n\\t\\tbufferbuilder.begin(GL11.GL_TRIANGLES, DefaultVertexFormats.POSITION_COLOR);\\n\\n\\t\\tbufferbuilder.vertex(x0, y0, 0).color(fc1 >> 16 & 0xFF, fc1 >> 8 & 0xFF, fc1 & 0xFF, fc1 >> 24 & 0xFF).endVertex();\\n\\t\\tbufferbuilder.vertex(x1, y1, 0).color(fc2 >> 16 & 0xFF, fc2 >> 8 & 0xFF, fc2 & 0xFF, fc2 >> 24 & 0xFF).endVertex();\\n\\t\\tbufferbuilder.vertex(x2, y2, 0).color(fc2 >> 16 & 0xFF, fc2 >> 8 & 0xFF, fc2 & 0xFF, fc2 >> 24 & 0xFF).endVertex();\\n\\n\\t\\tbufferbuilder.vertex(x0, y0, 0).color(fc1 >> 16 & 0xFF, fc1 >> 8 & 0xFF, fc1 & 0xFF, fc1 >> 24 & 0xFF).endVertex();\\n\\t\\tbufferbuilder.vertex(x2, y2, 0).color(fc2 >> 16 & 0xFF, fc2 >> 8 & 0xFF, fc2 & 0xFF, fc2 >> 24 & 0xFF).endVertex();\\n\\t\\tbufferbuilder.vertex(x3, y3, 0).color(fc2 >> 16 & 0xFF, fc2 >> 8 & 0xFF, fc2 & 0xFF, fc2 >> 24 & 0xFF).endVertex();\\n\\n\\t\\tbufferbuilder.vertex(x3, y3, 0).color(fc2 >> 16 & 0xFF, fc2 >> 8 & 0xFF, fc2 & 0xFF, fc2 >> 24 & 0xFF).endVertex();\\n\\t\\tbufferbuilder.vertex(x1, y1, 0).color(fc2 >> 16 & 0xFF, fc2 >> 8 & 0xFF, fc2 & 0xFF, fc2 >> 24 & 0xFF).endVertex();\\n\\t\\tbufferbuilder.vertex(x4, y4, 0).color(fc3 >> 16 & 0xFF, fc3 >> 8 & 0xFF, fc3 & 0xFF, fc3 >> 24 & 0xFF).endVertex();\\n\\n\\t\\tbufferbuilder.vertex(x3, y3, 0).color(fc2 >> 16 & 0xFF, fc2 >> 8 & 0xFF, fc2 & 0xFF, fc2 >> 24 & 0xFF).endVertex();\\n\\t\\tbufferbuilder.vertex(x4, y4, 0).color(fc3 >> 16 & 0xFF, fc3 >> 8 & 0xFF, fc3 & 0xFF, fc3 >> 24 & 0xFF).endVertex();\\n\\t\\tbufferbuilder.vertex(x6, y6, 0).color(fc3 >> 16 & 0xFF, fc3 >> 8 & 0xFF, fc3 & 0xFF, fc3 >> 24 & 0xFF).endVertex();\\n\\n\\t\\tbufferbuilder.vertex(x5, y5, 0).color(fc3 >> 16 & 0xFF, fc3 >> 8 & 0xFF, fc3 & 0xFF, fc3 >> 24 & 0xFF).endVertex();\\n\\t\\tbufferbuilder.vertex(x4, y4, 0).color(fc3 >> 16 & 0xFF, fc3 >> 8 & 0xFF, fc3 & 0xFF, fc3 >> 24 & 0xFF).endVertex();\\n\\t\\tbufferbuilder.vertex(x7, y7, 0).color(fc4 >> 16 & 0xFF, fc4 >> 8 & 0xFF, fc4 & 0xFF, fc4 >> 24 & 0xFF).endVertex();\\n\\n\\t\\tbufferbuilder.vertex(x6, y6, 0).color(fc3 >> 16 & 0xFF, fc3 >> 8 & 0xFF, fc3 & 0xFF, fc3 >> 24 & 0xFF).endVertex();\\n\\t\\tbufferbuilder.vertex(x5, y5, 0).color(fc3 >> 16 & 0xFF, fc3 >> 8 & 0xFF, fc3 & 0xFF, fc3 >> 24 & 0xFF).endVertex();\\n\\t\\tbufferbuilder.vertex(x8, y8, 0).color(fc4 >> 16 & 0xFF, fc4 >> 8 & 0xFF, fc4 & 0xFF, fc4 >> 24 & 0xFF).endVertex();\\n\\n\\t\\ttessellator.draw();\\n\\t\\tRenderSystem.shadeModel(GL11.GL_FLAT);\\n\\t\\tRenderSystem.disableBlend();\\n\\t\\tRenderSystem.enableAlphaTest();\\n\\t\\tRenderSystem.enableTexture();\\n\\t}\",\n \"@SuppressWarnings(\\\"unused\\\")\\r\\n private void JCATsegmentVisceralFat2D01() {\\r\\n \\r\\n // get the VOI for the external boundary of the abdomen\\r\\n VOIVector vois = abdomenImage.getVOIs();\\r\\n if(vois.size() != 1) {\\r\\n System.err.println(\\\"segmentVisceralFat2D() Error, did not get 1 VOI\\\");\\r\\n return;\\r\\n }\\r\\n\\r\\n // abdomenImage has one VOI, lets get it\\r\\n VOI theVOI = vois.get(0);\\r\\n \\r\\n // find the center-of-mass of the contour\\r\\n VOIContour maxContour = ((VOIContour)theVOI.getCurves().get(0));\\r\\n int[] xVals = new int [maxContour.size()];\\r\\n int[] yVals = new int [maxContour.size()];\\r\\n int[] zVals = new int [maxContour.size()];\\r\\n maxContour.exportArrays(xVals, yVals, zVals);\\r\\n \\r\\n int xcm = 0, ycm = 0, zcm = 0;\\r\\n for (int idx = 0; idx < maxContour.size(); idx++) {\\r\\n xcm += xVals[idx];\\r\\n ycm += yVals[idx];\\r\\n zcm += zVals[idx];\\r\\n }\\r\\n \\r\\n xcm /= maxContour.size();\\r\\n ycm /= maxContour.size();\\r\\n zcm /= maxContour.size();\\r\\n \\r\\n ViewUserInterface.getReference().getMessageFrame().append(\\\"Xcm: \\\" +xcm +\\\" Ycm: \\\" +ycm +\\\" Zcm: \\\" +zcm+\\\"\\\\n\\\", ViewJFrameMessage.DEBUG);\\r\\n \\r\\n // This point should be inside the abdomen\\r\\n // walk right until you find the external border of the abdomen\\r\\n \\r\\n // update the volumeBitSet to match the closed abdomenImage\\r\\n short[] srcSliceBuffer = new short[sliceSize];\\r\\n short[] profile = new short[xDim];\\r\\n try {\\r\\n abdomenImage.exportData(0, sliceSize, sliceBuffer);\\r\\n srcImage.exportData(0, sliceSize, srcSliceBuffer);\\r\\n } catch (IOException ex) {\\r\\n System.err.println(\\\"Error exporting data\\\");\\r\\n return;\\r\\n }\\r\\n\\r\\n int x = xcm;\\r\\n int elementCount = 0;\\r\\n int yOffset = ycm * xDim;\\r\\n while (x < xDim && sliceBuffer[x + yOffset] == abdomenTissueLabel) {\\r\\n profile[elementCount] = srcSliceBuffer[x + yOffset];\\r\\n x++;\\r\\n elementCount++;\\r\\n } // end while(...)\\r\\n \\r\\n // profile has an intensity profile of the pixels along the ray from the \\r\\n // contour CM to the external skin boundary. \\r\\n \\r\\n \\r\\n }\",\n \"private Vector combinationAlgorithm(Stroke theStroke){\\n\\t\\tCurvatureBasedDetection cbd = new CurvatureBasedDetection();\\n\\t\\tSpeedBasedDetection sbd = new SpeedBasedDetection();\\n\\t\\tCommonSegmentPts = new Vector();\\n\\t\\tCurvPts = cbd.getCurvatureData();\\n\\t\\tdouble SpeedPts[][] = sbd.getSpeedData();\\n\\t\\tCurvPtCount = cbd.getIndex();\\n\\t\\tint SpeedPtCount = sbd.getIndex();\\n\\t\\tint index ;\\n\\t\\tCurvVector = new Vector();\\n\\t\\t//copy the speed and curvature data in two vectors\\n\\t\\tfor (index = 0; index < CurvPtCount ; index++){\\n\\t\\t\\tDouble obj = CurvPts[index][0];\\n\\t\\t\\tCurvVector.add(new Integer(obj.intValue()));\\n\\t\\t}\\n\\t\\t\\n\\t\\tSystem.out.println(\\\"Curvature Indices\\\");\\n\\t\\tprintValues(CurvVector);\\n\\t\\t\\n\\t\\tSpeedVector = new Vector();\\n\\t\\tfor (index = 0; index < SpeedPtCount ; index++){\\n\\t\\t\\tDouble obj = SpeedPts[index][0];\\n\\t\\t\\tSpeedVector.add(new Integer(obj.intValue()));\\n\\t\\t}\\n\\t\\tSystem.out.println(\\\"Speed Indices\\\");\\n\\t\\tprintValues(SpeedVector);\\n\\t\\tSort sort = new Sort();\\n\\t\\tint ElementIndex;\\n\\t\\t// find common points (intersection of speed and curvature) and put it in CommonSegmentPts vector\\n\\t\\t\\n\\t\\tboolean flag = false;\\n\\t\\tfor(index = 0; index < SpeedVector.size(); index++ ){\\n\\t\\t\\t\\n\\t\\t\\tElementIndex = sort.linearSearch(CurvVector, (Integer)SpeedVector.elementAt(index));\\n\\t\\t\\t\\n\\t\\t\\tif(ElementIndex != -1){\\n\\t\\t\\t\\tCommonSegmentPts.add((Integer)(CurvVector.elementAt(ElementIndex)));\\n\\t\\t\\t\\tCurvVector.remove(ElementIndex);\\n\\t\\t\\t\\tSpeedVector.remove(index --); // point is removed from vectors\\n\\t\\t\\t\\t\\n\\t\\t\\t}\\t\\t\\n\\t\\t}\\n\\t\\tSystem.out.println(\\\"Common Points\\\");\\n\\t\\tprintValues(CommonSegmentPts);\\n\\t\\tint ElemAtIndex;\\n\\t\\t// Find the curvature based segment points in the Tolerance Distance of speed based segment points \\n\\t\\tfor(index = 0; index < SpeedVector.size(); index++ ){\\n\\t\\t\\tElementIndex = FindNearbyPts(CurvVector, (Integer)SpeedVector.elementAt(index), theStroke);\\n\\t\\t\\tif(ElementIndex != -1){\\n\\t\\t\\t\\tElemAtIndex = ((Integer)CurvVector.elementAt(ElementIndex) + (Integer)SpeedVector.elementAt(index))/2;\\n\\t\\t\\t\\tCommonSegmentPts.add(ElemAtIndex);\\n\\t\\t\\t\\tCurvVector.remove(ElementIndex);\\n\\t\\t\\t\\tSpeedVector.remove(index--);\\n\\t\\t\\t}\\n\\t\\t}\\n\\t\\t//printValues(CommonSegmentPts);\\n\\t\\tremoveNearbyPixels(theStroke);\\n\\t\\t//setNewScalingFactor(theStroke);\\n\\t\\tCollections.sort(CommonSegmentPts);\\n\\t\\tprintValues(CommonSegmentPts);\\n\\t\\tdouble PrevIterError;\\n\\t\\tdouble NewIterError;\\n\\t\\tVector IterationPts = new Vector(); \\n\\t\\t//System.out.println(\\\"Error \\\" + (PrevIterError = calculateError(CommonSegmentPts, theStroke)));\\n\\t\\t// create a vector that stores segment points of each iteration\\n\\t\\tIterWiseSegPts = new Vector();\\n\\t\\t// for hybrid\\n\\t\\tIterationPts = copyVector(IterationPts, CommonSegmentPts);\\n\\t\\tdouble PrevError = calculateError(IterationPts, theStroke);\\n\\t\\tif(PrevError > 10000.0){\\t// if stroke consists of curves\\n\\t\\t\\terrorTolerance = 90.0;\\n\\t\\t}\\n\\t\\tIterationPts.add((double ) PrevError);\\n\\t\\tIterWiseSegPts = appendVector(IterWiseSegPts,IterationPts);\\n\\t\\tdouble NewError = -1;\\n/*\\t\\tint vectorIndex = 0;\\n\\t\\t\\n\\t\\twhile(CurvVector.size()!=0 || SpeedVector.size()!=0){\\n\\t*/\\t\\t\\n\\t\\t\\t// code for accepting seg points uptil pts reduce the error by 100\\n\\t\\t/*\\n\\t\\t\\tif(CurvVector.size()!=0){\\n\\t\\t\\t\\tint CurvIndex = (Integer)CurvVector.get(0);\\n\\t\\t\\t\\tCommonSegmentPts.add(CurvIndex);\\n\\t\\t\\t\\tCurvVector.remove(0);\\n\\t\\t\\t\\tCollections.sort(CommonSegmentPts);\\n\\t\\t\\t\\tNewIterError = calculateError(CommonSegmentPts, theStroke);\\n\\t\\t\\t\\tif((PrevIterError - NewIterError) > 100.0){\\n\\t\\t\\t\\t\\tvectorIndex++;\\n\\t\\t\\t\\t\\tIterWiseSegPts.add(CurvIndex);\\n\\t\\t\\t\\t\\tPrevIterError = NewIterError;\\n\\t\\t\\t\\t}\\n\\t\\t\\t\\telse{\\n\\t\\t\\t\\t\\twhile(CurvVector.size()!=0){\\n\\t\\t\\t\\t\\t\\tCurvVector.remove(0);\\n\\t\\t\\t\\t\\t}\\t\\t\\t\\t\\t//return IterWiseSegPts;\\n\\t\\t\\t\\t}\\n\\t\\t\\t}\\n\\t\\t\\t\\n\\t\\t\\t\\n\\t\\t\\tif(SpeedVector.size()!=0){\\n\\t\\t\\t\\tint SpeedIndex = (Integer)SpeedVector.get(0);\\n\\t\\t\\t\\tCommonSegmentPts.add(SpeedIndex);\\n\\t\\t\\t\\tSpeedVector.remove(0);\\n\\t\\t\\t\\tCollections.sort(CommonSegmentPts);\\n\\t\\t\\t\\tNewIterError = calculateError(CommonSegmentPts, theStroke);\\n\\t\\t\\t\\tSystem.out.println(\\\"New Error = \\\" + NewIterError);\\n\\t\\t\\t//CommonSegmentPts.add((Double)NewIterError);\\n\\t\\t\\t\\tif((PrevIterError - NewIterError) > 100.0 ){\\n\\t\\t\\t\\t\\tvectorIndex++;\\n\\t\\t\\t\\t\\tIterWiseSegPts.add(SpeedIndex);\\n\\t\\t\\t\\t\\tPrevIterError = NewIterError;\\n\\t\\t\\t\\t}\\n\\t\\t\\t\\telse{\\n\\t\\t\\t\\t\\twhile(SpeedVector.size()!=0){\\n\\t\\t\\t\\t\\t\\tSpeedVector.remove(0);\\n\\t\\t\\t\\t\\t}\\t\\t\\n\\t\\t\\t\\t\\t//return IterWiseSegPts;\\n\\t\\t\\t\\t}\\n\\t\\t\\t\\n\\t\\t\\t\\t\\n\\t\\t\\t}*/\\n\\t\\t\\t// my approach\\n\\t/*\\t\\t\\n\\t\\t\\tif(CurvVector.size()!=0){\\n\\t\\t\\t\\tint Index = findMinimumErrorIndex(CurvVector,CommonSegmentPts,theStroke);\\n\\t\\t\\t\\tif(Index != -1){\\n\\t\\t\\t\\tint CurvIndex = (Integer)CurvVector.get(Index);\\n\\t\\t\\t\\tCommonSegmentPts.add((Integer)CurvIndex);\\n\\t\\t\\t\\tCurvVector.remove(Index);\\n\\t\\t\\t\\t}\\n\\t\\t\\t\\telse{\\n\\t\\t\\t\\t\\tCurvVector = clearVector(CurvVector);\\n\\t\\t\\t\\t}\\n\\t\\t\\t}\\n\\t\\t\\tif(SpeedVector.size()!=0){\\n\\t\\t\\t\\tint Index = findMinimumErrorIndex(SpeedVector,CommonSegmentPts,theStroke);\\n\\t\\t\\t\\tif(Index != -1){\\n\\t\\t\\t\\tint SpeedIndex = (Integer)SpeedVector.get(Index);\\n\\t\\t\\t\\tCommonSegmentPts.add((Integer)SpeedIndex);\\n\\t\\t\\t\\tSpeedVector.remove(Index);\\n\\t\\t\\t\\t}\\n\\t\\t\\t\\telse{\\n\\t\\t\\t\\t\\tSpeedVector = clearVector(SpeedVector);\\n\\t\\t\\t\\t}\\n\\t\\t\\t}\\n\\t\\t\\tIterationPts = clearVector(IterationPts);\\n\\t\\t\\tIterationPts = copyVector(IterationPts, CommonSegmentPts);\\n\\t\\t\\tCollections.sort(IterationPts);\\n\\t\\t\\tIterError = calculateError(IterationPts, theStroke);\\n\\t\\t\\tIterationPts.add((double) IterError);\\n\\t\\t\\tIterWiseSegPts = appendVector(IterWiseSegPts,IterationPts);\\n\\t\\t\\tremoveNearbyPixels(theStroke);\\n\\n\\t\\t}\\n\\t\\tCommonSegmentPts = clearVector(CommonSegmentPts);\\n\\t\\tCommonSegmentPts = selectBestSegPtsSet(IterWiseSegPts);*/\\n\\t\\t\\n\\t\\t/*\\tif(CurvVector.size()!=0){\\n\\t\\tint Index = findMinimumErrorIndex(CurvVector,CommonSegmentPts,theStroke);\\n\\t\\tif(Index != -1){\\n\\t\\tint CurvIndex = (Integer)CurvVector.get(Index);\\n\\t\\tCommonSegmentPts.add((Integer)CurvIndex);\\n\\t\\tCurvVector.remove(Index);\\n\\t\\t}\\n\\t\\telse{\\n\\t\\t\\tCurvVector = clearVector(CurvVector);\\n\\t\\t}\\n\\t}\\n\\tif(SpeedVector.size()!=0){\\n\\t\\tint Index = findMinimumErrorIndex(SpeedVector,CommonSegmentPts,theStroke);\\n\\t\\tif(Index != -1){\\n\\t\\tint SpeedIndex = (Integer)SpeedVector.get(Index);\\n\\t\\tCommonSegmentPts.add((Integer)SpeedIndex);\\n\\t\\tSpeedVector.remove(Index);\\n\\t\\t}\\n\\t\\telse{\\n\\t\\t\\tSpeedVector = clearVector(SpeedVector);\\n\\t\\t}\\n\\t}\\n\\tIterationPts = clearVector(IterationPts);\\n\\tIterationPts = copyVector(IterationPts, CommonSegmentPts);\\n\\tCollections.sort(IterationPts);\\n\\tIterError = calculateError(IterationPts, theStroke);\\n\\tIterationPts.add((double) IterError);\\n\\tIterWiseSegPts = appendVector(IterWiseSegPts,IterationPts);\\n\\tremoveNearbyPixels(theStroke);\\n\\n}\\nCommonSegmentPts = clearVector(CommonSegmentPts);\\nCommonSegmentPts = selectBestSegPtsSet(IterWiseSegPts);*/\\n\\t\\t\\n\\t\\t\\n\\t\\t// hybrid fit approach\\n\\t\\tint curvIndex = -1, speedIndex = -1;\\n\\t\\tdouble curvError,speedError;\\n\\t\\tVector curvPts = new Vector();\\n\\t\\tVector speedPts = new Vector();\\n\\t\\tVector changeInError = new Vector();\\n\\t\\twhile((CurvVector.size() != 0) || (SpeedVector.size() != 0) ){\\n\\t\\t\\tcurvError = DEFAULT;\\n\\t\\t\\tspeedError = DEFAULT;\\n\\t\\t\\t\\n\\t\\t\\tif(CurvVector.size() != 0){\\n\\t\\t\\t\\tclearVector(curvPts);\\n\\t\\t\\t\\tcurvPts = copyVector(curvPts, CommonSegmentPts);\\n\\t\\t\\t\\tcurvIndex = (Integer)CurvVector.get(0);\\n\\t\\t\\t\\tcurvPts.add((Integer)curvIndex);\\n\\t\\t\\t\\tCurvVector.remove(0);\\n\\t\\t\\t\\tCollections.sort(curvPts);\\n\\t\\t\\t\\tcurvError = calculateError(curvPts, theStroke);\\n\\t\\t\\t\\tcurvPts.add((Double)curvError);\\n\\t\\t\\t}\\n\\t\\t\\t\\n\\t\\t\\tif(SpeedVector.size() != 0){\\n\\t\\t\\t\\tclearVector(speedPts);\\n\\t\\t\\t\\tspeedPts = copyVector(speedPts, CommonSegmentPts);\\n\\t\\t\\t\\tspeedIndex = (Integer)SpeedVector.get(0);\\n\\t\\t\\t\\tspeedPts.add((Integer)speedIndex);\\n\\t\\t\\t\\tSpeedVector.remove(0);\\n\\t\\t\\t\\tCollections.sort(speedPts);\\n\\t\\t\\t\\tspeedError = calculateError(speedPts, theStroke);\\n\\t\\t\\t\\tspeedPts.add((Double)speedError);\\n\\t\\t\\t}\\n\\t\\t\\t\\n\\t\\t\\tif((speedError <= curvError) || (curvError == DEFAULT)){\\n\\t\\t\\t\\tNewError = speedError;\\n\\t\\t\\t\\t//changeInError.add((Double)(NewError - PrevError));\\n\\t\\t\\t\\tif((PrevError - NewError) > errorTolerance){\\n\\t\\t\\t\\tIterWiseSegPts = appendVector(IterWiseSegPts, speedPts);\\n\\t\\t\\t\\tCommonSegmentPts.add((Integer)speedIndex);\\n\\t\\t\\t\\tchangeInError.add((Double)(PrevError - NewError));\\n\\t\\t\\t\\tPrevError = NewError;\\n\\t\\t\\t\\t}\\n\\t\\t\\t}\\n\\t\\t\\telse if((curvError < speedError) || (speedError == DEFAULT)){\\n\\t\\t\\t\\tNewError = curvError;\\n\\t\\t\\t\\tif((PrevError - NewError) > errorTolerance){\\n\\t\\t\\t\\tIterWiseSegPts = appendVector(IterWiseSegPts, curvPts);\\n\\t\\t\\t\\tCommonSegmentPts.add((Integer)curvIndex);\\n\\t\\t\\t\\tchangeInError.add((Double)(PrevError - NewError));\\n\\t\\t\\t\\tPrevError = NewError;\\n\\t\\t\\t\\t}\\n\\t\\t\\t}\\n\\t\\t\\n\\t\\t\\t\\n\\t\\t}\\n\\t\\t\\t\\n\\t\\tCommonSegmentPts = clearVector(CommonSegmentPts);\\n\\t\\tVector TempVect = new Vector();\\n\\t\\tCommonSegmentPts = copyVectorIndex(IterWiseSegPts, TempVect, IterWiseSegPts.size() - 1);\\n\\t\\t//TempVect = copyVectorIndex(IterWiseSegPts, TempVect, IterWiseSegPts.size() -1);\\n\\t\\t/*index = 0;\\n\\t\\twhile(index < (TempVect.size()-1)){\\n\\t\\t\\tCommonSegmentPts.add((Integer)TempVect.get(index++));\\n\\t\\t}*/\\n\\t\\t//CommonSegmentPts = selectBestSegPtsSet(IterWiseSegPts);\\n\\t\\t\\n\\t\\treturn CommonSegmentPts;\\n\\t}\",\n \"private void setCofR() {\\n\\t\\t\\n Vector3f pos_vec = new Vector3f();\\n Point3f pos = new Point3f();\\n Vector3f dir = new Vector3f();\\n\\t\\tMatrix4f view_mtx = new Matrix4f();\\n\\t\\tMatrix4f nav_mtx = new Matrix4f();\\n Point3f cor = new Point3f();\\n\\t\\t\\n\\t\\tnavigationTransform.getTransform(nav_mtx);\\n\\t\\t\\n\\t\\tdata.viewpointTransform.getTransform(view_mtx);\\n\\t\\tview_mtx.get(pos_vec);\\n\\t\\t\\n\\t\\t// the eye point\\n\\t\\tpos.set(pos_vec);\\n\\t\\t\\n\\t\\t// the eye direction\\n\\t\\tdir.x = view_mtx.m02;\\n\\t\\tdir.y = view_mtx.m12;\\n\\t\\tdir.z = view_mtx.m22;\\n\\t\\tdir.negate();\\n\\t\\tdir.normalize();\\n\\t\\t\\n\\t\\t// transform into world space\\n\\t\\tnav_mtx.transform(pos);\\n\\t\\tnav_mtx.transform(dir);\\n\\t\\t\\n\\t\\tArrayList pickResults = new ArrayList();\\n\\t\\tPickRequest pickRequest = new PickRequest();\\n\\t\\tpickRequest.pickGeometryType = PickRequest.PICK_RAY;\\n\\t\\tpickRequest.pickSortType = PickRequest.SORT_ORDERED;\\n\\t\\tpickRequest.pickType = PickRequest.FIND_GENERAL;\\n\\t\\tpickRequest.useGeometry = false;\\n\\t\\tpickRequest.foundPaths = pickResults;\\n\\t\\t\\n\\t\\t// initialize the pick request\\n\\t\\tpickRequest.origin[0] = pos.x;\\n\\t\\tpickRequest.origin[1] = pos.y;\\n\\t\\tpickRequest.origin[2] = pos.z;\\n\\t\\t\\n\\t\\tpickRequest.destination[0] = dir.x;\\n\\t\\tpickRequest.destination[1] = dir.y;\\n\\t\\tpickRequest.destination[2] = dir.z;\\n\\t\\t\\n\\t\\trootGroup.pickSingle(pickRequest);\\n\\t\\t\\n\\t\\tif (pickRequest.pickCount > 0) {\\n\\t\\t\\t\\n \\tPoint3f intersectPoint = new Point3f();\\n \\tVector3f intersectVector = new Vector3f();\\n\\t\\t\\n\\t\\t\\tfloat min_distance = Float.MAX_VALUE;\\n\\t\\t\\t// sort through the bounds intersections\\n\\t\\t\\tint num_pick = pickResults.size();\\n\\t\\t\\tfor (int i = 0; i < num_pick; i++) {\\n\\t\\t\\t\\t\\n\\t\\t\\t\\tSceneGraphPath sgp = (SceneGraphPath)pickResults.get(i);\\n\\t\\t\\t\\tsgp.getTransform(view_mtx);\\n\\t\\t\\t\\t\\n\\t\\t\\t\\tShape3D shape = (Shape3D)sgp.getTerminalNode();\\n\\t\\t\\t\\tVertexGeometry geom = (VertexGeometry)shape.getGeometry();\\n\\t\\t\\t\\t\\n\\t\\t\\t\\t//determine if there was an actual geometry intersection\\n\\t\\t\\t\\tboolean intersect = iutils.rayUnknownGeometry(\\n\\t\\t\\t\\t\\tpos,\\n\\t\\t\\t\\t\\tdir,\\n\\t\\t\\t\\t\\t0,\\n\\t\\t\\t\\t\\tgeom,\\n\\t\\t\\t\\t\\tview_mtx,\\n\\t\\t\\t\\t\\tintersectPoint,\\n\\t\\t\\t\\t\\tfalse);\\n\\t\\t\\t\\t\\n\\t\\t\\t\\tif (intersect) {\\n\\t\\t\\t\\t\\tintersectVector.set(\\n\\t\\t\\t\\t\\t\\tintersectPoint.x - pos.x,\\n\\t\\t\\t\\t\\t\\tintersectPoint.y - pos.y,\\n\\t\\t\\t\\t\\t\\tintersectPoint.z - pos.z);\\n\\n\\t\\t\\t\\t\\tfloat distance = intersectVector.length();\\n\\t\\t\\t\\t\\tif (distance < min_distance) {\\n\\t\\t\\t\\t\\t\\tmin_distance = distance;\\n\\t\\t\\t\\t\\t\\tcor.set(intersectPoint);\\n\\t\\t\\t\\t\\t}\\n\\t\\t\\t\\t}\\n\\t\\t\\t} \\n\\t\\t\\tnav_mtx.invert();\\n\\t\\t\\tnav_mtx.transform(cor);\\n\\t\\t}\\n\\t\\tcenterOfRotation.set(cor);\\n\\t}\",\n \"public BranchGroup cubo2(){\\n\\t\\t\\tBranchGroup objRoot = new BranchGroup();\\n\\n\\t TransformGroup objScale = new TransformGroup();\\n\\t Transform3D t3d = new Transform3D();\\n\\t Transform3D rotate = new Transform3D();\\n Transform3D tempRotate = new Transform3D();\\n\\t \\t rotate.rotX(Math.PI/1.0d);\\n tempRotate.rotY(Math.PI/1.80d);\\n Matrix3d n = new Matrix3d();\\n Vector3d op = new Vector3d(.2,.05,.2);\\n tempRotate.setScale(op);\\n Vector3d op2 = new Vector3d(.5,.6,.5);\\n tempRotate.setTranslation(op2);\\n rotate.mul(tempRotate);\\n // rotate.mul(objScale);\\n TransformGroup objRotate = new TransformGroup(rotate);\\n \\n //objRotate.addChild(new ColorCube(0.4));\\n objRoot.addChild(objRotate);\\n\\t \\n t3d.mul(rotate);\\n\\t objScale.setTransform(t3d);\\n\\t \\n\\t objRoot.addChild(objScale);\\n\\n\\tTransformGroup objTrans = new TransformGroup();\\n\\t\\tobjTrans.setCapability(TransformGroup.ALLOW_TRANSFORM_WRITE);\\n\\t\\tobjTrans.setCapability(TransformGroup.ALLOW_TRANSFORM_READ);\\n\\t\\t\\t\\t\\t\\n\\t\\t\\n\\t\\tobjScale.addChild(objTrans);\\n\\n\\t\\tint flags = ObjectFile.RESIZE;\\n\\t\\tif (!noTriangulate) flags |= ObjectFile.TRIANGULATE;\\n\\t\\tif (!noStripify) flags |= ObjectFile.STRIPIFY;\\n\\t\\tObjectFile f = new ObjectFile(flags, \\n\\t\\t (float)(creaseAngle * Math.PI / 180.0));\\n\\t\\tScene s = null;\\n\\t\\ttry {\\n\\t\\t s = f.load(filename);\\n\\t\\t}\\n\\t\\tcatch (FileNotFoundException e) {\\n\\t\\t System.err.println(e);\\n\\t\\t System.exit(1);\\n\\t\\t}\\n\\t\\tcatch (ParsingErrorException e) {\\n\\t\\t System.err.println(e);\\n\\t\\t System.exit(1);\\n\\t\\t}\\n\\t\\tcatch (IncorrectFormatException e) {\\n\\t\\t System.err.println(e);\\n\\t\\t System.exit(1);\\n\\t\\t}\\n\\t\\t \\n\\t\\tobjTrans.addChild(s.getSceneGroup());\\n\\t\\t\\n \\n \\n\\t\\tBoundingSphere bounds = new BoundingSphere(new Point3d(0.0,0.0,0.0), 100.0);\\n\\n\\n\\t \\n\\t // Set up the background\\n\\t Color3f bgColor = new Color3f(0.05f, 0.05f, 0.5f);\\n\\t Background bgNode = new Background(bgColor);\\n\\t bgNode.setApplicationBounds(bounds);\\n\\t objRoot.addChild(bgNode);\\n\\n\\t\\treturn objRoot;\\n\\t\\t \\n\\t }\",\n \"private boolean isOnCylinder(Point3D point) {\\n // the vector from bottom to the point\\n Vector vec1 = new Vector(Point3D.substract(orientation.getPOO(), point));\\n\\n // the vector from the top to point\\n Vector vec2 = new Vector(Point3D.substract(top, point));\\n\\n // the vectors to the edges of cylinder\\n Vector vec3 = new Vector(Point3D.substract(orientation.getPOO(), point));\\n\\n Vector vec4 = new Vector(Point3D.substract(top, point));\\n\\n double Vec3dot = Vector.dotProduct(vec3, orientation.getDirection());\\n\\n double Vec4dot = Vector.dotProduct(vec4, orientation.getDirection());\\n if (Vec3dot == 0)\\n if (_radius - vec3.length() >= 0)\\n return true;\\n if (Vec4dot == 0)\\n if (_radius - vec4.length() >= 0)\\n return true;\\n\\n if (Vector.dotProduct(vec1, orientation.getDirection()) > 0\\n && Vector.dotProduct(vec2, orientation.getDirection()) < 0)\\n return true;\\n return false;\\n }\",\n \"public void lungs(Graphics bbg, int n, int length, int x, int y, double angle){\\n double r1 = angle + Math.toRadians(-45);\\n double r2 = angle + Math.toRadians(45);\\n double r3 = angle + Math.toRadians(135);\\n double r4 = angle + Math.toRadians(-135);\\n\\n //length modifications of the different branches\\n double l1 = length/1.3 + (l1I*5);\\n double l2 = length/1.3 + (l2I*5);\\n double l3 = length/1.3 + (l3I*5);\\n double l4 = length/1.3 + (l4I*5);\\n\\n //x and y points of the end of the different branches\\n int ax = (int)(x - Math.sin(r1)*l1)+(int)(l1I);\\n int ay = (int)(y - Math.cos(r1)*l1)+(int)(l1I);\\n int bx = (int)(x - Math.sin(r2)*l2)+(int)(l2I);\\n int by = (int)(y - Math.cos(r2)*l2)+(int)(l2I);\\n int cx = (int)(x - Math.sin(r3)*l3)+(int)(l3I);\\n int cy = (int)(y - Math.cos(r3)*l3)+(int)(l3I);\\n int dx = (int)(x - Math.sin(r4)*l4)+(int)(l4I);\\n int dy = (int)(y - Math.cos(r4)*l4)+(int)(l4I);\\n\\n if(n == 0){\\n return;\\n }\\n\\n\\n increment();\\n Color fluidC = new Color(colorR,colorG,colorB);\\n //bbg.setColor(new Color((int) (Math.random() * 255), (int) (Math.random() * 255), (int) (Math.random()*255)));\\n bbg.setColor(fluidC);\\n\\n\\n //draw different branches\\n bbg.drawLine(x,y,ax,ay);\\n bbg.drawLine(x,y,bx,by);\\n bbg.drawLine(x,y,cx,cy);\\n bbg.drawLine(x,y,dx,dy);\\n\\n\\n\\n //call recursively to draw fractal\\n lungs(bbg, n - 1, (int)l1, ax,ay,r1);\\n lungs(bbg, n - 1, (int)l2, bx,by,r2);\\n lungs(bbg, n - 1, (int)l3, cx,cy,r3);\\n lungs(bbg, n - 1, (int)l4, dx,dy,r4);\\n\\n\\n }\",\n \"public void ignoreCreateArrayForVec2With6Position() {\\r\\n\\r\\n SXRMesh sxrMesh = TestDefaultSXRViewManager.mSXRContext.getAssetLoader().loadMesh(UtilResource.androidResource(TestDefaultSXRViewManager.mSXRContext,R.raw.cylinder3));\\r\\n float[] vec2 = {-0.5f, 0.5f, 0.0f, -0.5f, 0.5f, 0.0f};\\r\\n\\r\\n try {\\r\\n sxrMesh.setVec3Vector(\\\"ratio_r\\\", vec2);\\r\\n assertNotNull(sxrMesh.getVec4Vector(\\\"ratio_r\\\"));\\r\\n fail();\\r\\n } catch (Exception e) {\\r\\n assertEquals(e.getMessage(), \\\"setVec2Vector method support only three position array\\\");\\r\\n }\\r\\n }\",\n \"public CircularGrid(int ringCount, boolean verticalCut, boolean horizontalCut) {\\r\\n\\t\\tif (ringCount<0)\\r\\n\\t\\t\\tthrow new IllegalArgumentException(\\\"The number of rings is illegal: \\\"+ringCount);\\r\\n\\t\\tint columnCount = 2*(ringCount-1) + ((verticalCut)?2:1);\\r\\n\\t\\tint rowCount = 2*(ringCount-1) + ((horizontalCut)?2:1);\\r\\n\\t\\tinit(columnCount, rowCount);\\r\\n\\t}\",\n \"private static double[][] makeRegularPoly(double centerLat, double centerLon, double radiusMeters, int gons) {\\n\\n double[][] result = new double[2][];\\n result[0] = new double[gons+1];\\n result[1] = new double[gons+1];\\n for(int i=0;i radiusMeters) {\\n // too big\\n //System.out.println(\\\" smaller\\\");\\n factor -= step;\\n if (last == 1) {\\n //System.out.println(\\\" half-step\\\");\\n step /= 2.0;\\n }\\n last = -1;\\n } else if (distanceMeters < radiusMeters) {\\n // too small\\n //System.out.println(\\\" bigger\\\");\\n factor += step;\\n if (last == -1) {\\n //System.out.println(\\\" half-step\\\");\\n step /= 2.0;\\n }\\n last = 1;\\n }\\n }\\n }\\n\\n // close poly\\n result[0][gons] = result[0][0];\\n result[1][gons] = result[1][0];\\n\\n return result;\\n }\",\n \"protected void building(double xCoord, double yCoord, double len, double width, double height)\\n {\\n double x1 = (xCoord - (width/2)); // Low x\\n double x2 = (xCoord + (width/2)); // High x\\n double y1 = (yCoord - (len/2)); // Low y\\n double y2 = (yCoord + (len/2)); // High y\\n\\n Vertex vertex1, vertex2, vertex3;\\n\\n Triple pos1, pos2, pos3, pos4, pos5, pos6, pos7, pos8, col1, col2, col3, col4;\\n Vertex vert1, vert2, vert3;\\n\\n pos1 = new Triple(x1, y1, 0); \\n pos2 = new Triple(x2, y1, 0); \\n pos3 = new Triple(x2, y1, height);\\n pos4 = new Triple(x1, y1, height);\\n pos5 = new Triple(x1, y2, 0); \\n pos6 = new Triple(x2, y2, 0); \\n pos7 = new Triple(x2, y2, height);\\n pos8 = new Triple(x1, y2, height);\\n\\n col1 = new Triple(1, 0, 0); \\n col2 = new Triple(0, 1, 0); \\n col3 = new Triple(0, 0, 1); \\n col4 = new Triple(1, 0, 1); \\n \\n // Front Triangles\\n frozenSoups.addTri( new Triangle(new Vertex(pos1, 0, 0), \\n new Vertex(pos2, 0, 1), \\n new Vertex(pos3, 1, 1), \\n\\t\\t\\t\\t 25 ) );\\n\\n frozenSoups.addTri( new Triangle(new Vertex(pos3, 1, 1), \\n new Vertex(pos4, 1, 0), \\n new Vertex(pos1, 0, 0),\\n 25 ) );\\n \\n // Left Triangles\\n frozenSoups.addTri( new Triangle(new Vertex(pos1, 0, 0), \\n new Vertex(pos5, 0, 1), \\n new Vertex(pos8, 1, 1),\\n 26 ) );\\n\\n frozenSoups.addTri( new Triangle(new Vertex(pos8, 1, 1), \\n new Vertex(pos4, 1, 0), \\n new Vertex(pos1, 0, 0),\\n 26 ) );\\n\\n // Right Triangles\\n frozenSoups.addTri( new Triangle(new Vertex(pos2, 0, 0), \\n new Vertex(pos6, 0, 1), \\n new Vertex(pos7, 1, 1),\\n 24 ) );\\n\\n frozenSoups.addTri( new Triangle(new Vertex(pos7, 1, 1), \\n new Vertex(pos3, 1, 0), \\n new Vertex(pos2, 0, 0),\\n 24 ) );\\n\\n // Back Triangles\\n frozenSoups.addTri( new Triangle(new Vertex(pos5, 0, 0), \\n new Vertex(pos6, 0, 1), \\n new Vertex(pos7, 1, 1),\\n 27 ) );\\n\\n frozenSoups.addTri( new Triangle(new Vertex(pos7, 1, 1), \\n new Vertex(pos8, 1, 0), \\n new Vertex(pos5, 0, 0),\\n 27 ) );\\n\\n // Top Triangles\\n frozenSoups.addTri( new Triangle(new Vertex(pos4, 0, 0), \\n new Vertex(pos3, 0, 1), \\n new Vertex(pos7, 1, 1),\\n 28 ) );\\n\\n frozenSoups.addTri( new Triangle(new Vertex(pos7, 1, 1), \\n new Vertex(pos8, 1, 0), \\n new Vertex(pos4, 0, 0),\\n 28 ) );\\n }\",\n \"public DynamicModelPart addCuboids() {\\n for (int i = 0; i < this.x.length; i++) {\\n this.addCuboid(this.x[i], this.y[i], this.z[i], this.sizeX[i], this.sizeY[i],\\n this.sizeZ[i], this.extra[i], this.u[i], this.v[i]);\\n }\\n return this;\\n }\",\n \"public void constructBoundingBox()\\r\\n\\t{\\n\\t\\tdouble a = m_Qmin.x;\\r\\n\\t\\tdouble b = m_Qmin.y;\\r\\n\\t\\tdouble c = m_Qmin.z;\\r\\n\\r\\n\\t\\tdouble d = m_Qmax.x;\\r\\n\\t\\tdouble e = m_Qmax.y;\\r\\n\\t\\tdouble f = m_Qmax.z;\\r\\n\\r\\n\\t\\t//constructing the vertexes of the bounding box\\r\\n\\t\\tSceneVertex A = new SceneVertex( new Vector3d(a, b, c));\\r\\n\\t\\tSceneVertex B = new SceneVertex( new Vector3d(d, b, c));\\r\\n\\t\\tSceneVertex C = new SceneVertex( new Vector3d(d, b, f));\\r\\n\\t\\tSceneVertex D = new SceneVertex( new Vector3d(d, e, f));\\r\\n\\t\\tSceneVertex E = new SceneVertex( new Vector3d(a, e, f));\\r\\n\\t\\tSceneVertex F = new SceneVertex( new Vector3d(a, e, c));\\r\\n\\t\\tSceneVertex G = new SceneVertex( new Vector3d(d, e, c));\\r\\n\\t\\tSceneVertex H = new SceneVertex( new Vector3d(a, b, f));\\r\\n\\r\\n\\r\\n\\t\\t// building the vertices arrays for the faces\\r\\n\\t\\tArrayList verArrP0front = new ArrayList(4);\\r\\n\\t\\tverArrP0front.add(A);\\r\\n\\t\\tverArrP0front.add(B);\\r\\n\\t\\tverArrP0front.add(G);\\r\\n\\t\\tverArrP0front.add(F);\\r\\n\\t\\t\\r\\n\\t\\tArrayList verArrP1left = new ArrayList(4);\\r\\n\\t\\tverArrP1left.add(A);\\r\\n\\t\\tverArrP1left.add(F);\\r\\n\\t\\tverArrP1left.add(E);\\r\\n\\t\\tverArrP1left.add(H);\\r\\n\\t\\t\\r\\n\\t\\tArrayList verArrP2back = new ArrayList(4);\\r\\n\\t\\tverArrP2back.add(H);\\r\\n\\t\\tverArrP2back.add(C);\\r\\n\\t\\tverArrP2back.add(D);\\r\\n\\t\\tverArrP2back.add(E);\\r\\n\\t\\t\\r\\n\\t\\tArrayList verArrP3right = new ArrayList(4);\\r\\n\\t\\tverArrP3right.add(G);\\r\\n\\t\\tverArrP3right.add(D);\\r\\n\\t\\tverArrP3right.add(C);\\r\\n\\t\\tverArrP3right.add(B);\\r\\n\\t\\t\\r\\n\\t\\tArrayList verArrP4bottom = new ArrayList(4);\\r\\n\\t\\tverArrP4bottom.add(A);\\r\\n\\t\\tverArrP4bottom.add(H);\\r\\n\\t\\tverArrP4bottom.add(C);\\r\\n\\t\\tverArrP4bottom.add(B);\\r\\n\\r\\n\\t\\tArrayList verArrP5top = new ArrayList(4);\\r\\n\\t\\tverArrP5top.add(F);\\r\\n\\t\\tverArrP5top.add(G);\\r\\n\\t\\tverArrP5top.add(D);\\r\\n\\t\\tverArrP5top.add(E);\\r\\n\\t\\t\\r\\n\\t\\t// creating BoundingBox\\r\\n\\t\\tm_BoundingBox = new SceneNode(DrawingMode.GL_LINE, \\\"BoundingBox\\\", null);\\r\\n\\t\\tm_BoundingBox.addChild( new ScenePolygon(verArrP0front, \\\"FRONT\\\"));\\r\\n\\t\\tm_BoundingBox.addChild( new ScenePolygon(verArrP1left, \\\"LEFT\\\"));\\r\\n\\t\\tm_BoundingBox.addChild( new ScenePolygon(verArrP2back, \\\"BACK\\\"));\\r\\n\\t\\tm_BoundingBox.addChild( new ScenePolygon(verArrP3right, \\\"RIGHT\\\"));\\r\\n\\t\\tm_BoundingBox.addChild( new ScenePolygon(verArrP4bottom, \\\"BOTTOM\\\"));\\r\\n\\t\\tm_BoundingBox.addChild( new ScenePolygon(verArrP5top, \\\"TOP\\\"));\\r\\n\\r\\n\\t\\t\\r\\n\\t}\",\n \"public Triangle (double x1,double y1,double x2, double y2)\\r\\n {\\r\\n v1 = new Point(x1,y1);\\r\\n v2 = new Point(x2,y2);\\r\\n v3 = new Point(0,0);\\r\\n }\",\n \"public void drawNearClippedFace(int face) {\\n\\t\\tint centerX = Draw3D.centerX;\\n\\t\\tint centerY = Draw3D.centerY;\\n\\t\\tint elements = 0;\\n\\n\\t\\tint a = faceVertexA[face];\\n\\t\\tint b = faceVertexB[face];\\n\\t\\tint c = faceVertexC[face];\\n\\n\\t\\tint zA = vertexViewSpaceZ[a];\\n\\t\\tint zB = vertexViewSpaceZ[b];\\n\\t\\tint zC = vertexViewSpaceZ[c];\\n\\n\\t\\tif (zA >= 50) {\\n\\t\\t\\tclippedX[elements] = vertexScreenX[a];\\n\\t\\t\\tclippedY[elements] = vertexScreenY[a];\\n\\t\\t\\tclippedColor[elements++] = faceColorA[face];\\n\\t\\t} else {\\n\\t\\t\\tint xA = vertexViewSpaceX[a];\\n\\t\\t\\tint yA = vertexViewSpaceY[a];\\n\\t\\t\\tint colorA = faceColorA[face];\\n\\n\\t\\t\\tif (zC >= 50) {\\n\\t\\t\\t\\tint scalar = (50 - zA) * reciprical16[zC - zA];\\n\\t\\t\\t\\tclippedX[elements] = centerX + (((xA + (((vertexViewSpaceX[c] - xA) * scalar) >> 16)) << 9) / 50);\\n\\t\\t\\t\\tclippedY[elements] = centerY + (((yA + (((vertexViewSpaceY[c] - yA) * scalar) >> 16)) << 9) / 50);\\n\\t\\t\\t\\tclippedColor[elements++] = colorA + (((faceColorC[face] - colorA) * scalar) >> 16);\\n\\t\\t\\t}\\n\\n\\t\\t\\tif (zB >= 50) {\\n\\t\\t\\t\\tint scalar = (50 - zA) * reciprical16[zB - zA];\\n\\t\\t\\t\\tclippedX[elements] = centerX + (((xA + (((vertexViewSpaceX[b] - xA) * scalar) >> 16)) << 9) / 50);\\n\\t\\t\\t\\tclippedY[elements] = centerY + (((yA + (((vertexViewSpaceY[b] - yA) * scalar) >> 16)) << 9) / 50);\\n\\t\\t\\t\\tclippedColor[elements++] = colorA + (((faceColorB[face] - colorA) * scalar) >> 16);\\n\\t\\t\\t}\\n\\t\\t}\\n\\n\\t\\tif (zB >= 50) {\\n\\t\\t\\tclippedX[elements] = vertexScreenX[b];\\n\\t\\t\\tclippedY[elements] = vertexScreenY[b];\\n\\t\\t\\tclippedColor[elements++] = faceColorB[face];\\n\\t\\t} else {\\n\\t\\t\\tint xB = vertexViewSpaceX[b];\\n\\t\\t\\tint yB = vertexViewSpaceY[b];\\n\\t\\t\\tint colorB = faceColorB[face];\\n\\n\\t\\t\\tif (zA >= 50) {\\n\\t\\t\\t\\tint scalar = (50 - zB) * reciprical16[zA - zB];\\n\\t\\t\\t\\tclippedX[elements] = centerX + (((xB + (((vertexViewSpaceX[a] - xB) * scalar) >> 16)) << 9) / 50);\\n\\t\\t\\t\\tclippedY[elements] = centerY + (((yB + (((vertexViewSpaceY[a] - yB) * scalar) >> 16)) << 9) / 50);\\n\\t\\t\\t\\tclippedColor[elements++] = colorB + (((faceColorA[face] - colorB) * scalar) >> 16);\\n\\t\\t\\t}\\n\\n\\t\\t\\tif (zC >= 50) {\\n\\t\\t\\t\\tint scalar = (50 - zB) * reciprical16[zC - zB];\\n\\t\\t\\t\\tclippedX[elements] = centerX + (((xB + (((vertexViewSpaceX[c] - xB) * scalar) >> 16)) << 9) / 50);\\n\\t\\t\\t\\tclippedY[elements] = centerY + (((yB + (((vertexViewSpaceY[c] - yB) * scalar) >> 16)) << 9) / 50);\\n\\t\\t\\t\\tclippedColor[elements++] = colorB + (((faceColorC[face] - colorB) * scalar) >> 16);\\n\\t\\t\\t}\\n\\t\\t}\\n\\n\\t\\tif (zC >= 50) {\\n\\t\\t\\tclippedX[elements] = vertexScreenX[c];\\n\\t\\t\\tclippedY[elements] = vertexScreenY[c];\\n\\t\\t\\tclippedColor[elements++] = faceColorC[face];\\n\\t\\t} else {\\n\\t\\t\\tint xC = vertexViewSpaceX[c];\\n\\t\\t\\tint yC = vertexViewSpaceY[c];\\n\\t\\t\\tint colorC = faceColorC[face];\\n\\n\\t\\t\\tif (zB >= 50) {\\n\\t\\t\\t\\tint k6 = (50 - zC) * reciprical16[zB - zC];\\n\\t\\t\\t\\tclippedX[elements] = centerX + (((xC + (((vertexViewSpaceX[b] - xC) * k6) >> 16)) << 9) / 50);\\n\\t\\t\\t\\tclippedY[elements] = centerY + (((yC + (((vertexViewSpaceY[b] - yC) * k6) >> 16)) << 9) / 50);\\n\\t\\t\\t\\tclippedColor[elements++] = colorC + (((faceColorB[face] - colorC) * k6) >> 16);\\n\\t\\t\\t}\\n\\n\\t\\t\\tif (zA >= 50) {\\n\\t\\t\\t\\tint l6 = (50 - zC) * reciprical16[zA - zC];\\n\\t\\t\\t\\tclippedX[elements] = centerX + (((xC + (((vertexViewSpaceX[a] - xC) * l6) >> 16)) << 9) / 50);\\n\\t\\t\\t\\tclippedY[elements] = centerY + (((yC + (((vertexViewSpaceY[a] - yC) * l6) >> 16)) << 9) / 50);\\n\\t\\t\\t\\tclippedColor[elements++] = colorC + (((faceColorA[face] - colorC) * l6) >> 16);\\n\\t\\t\\t}\\n\\t\\t}\\n\\n\\t\\tint x0 = clippedX[0];\\n\\t\\tint x1 = clippedX[1];\\n\\t\\tint x2 = clippedX[2];\\n\\t\\tint y0 = clippedY[0];\\n\\t\\tint y1 = clippedY[1];\\n\\t\\tint y2 = clippedY[2];\\n\\n\\t\\t// Back-face culling\\n\\t\\tif ((((x0 - x1) * (y2 - y1)) - ((y0 - y1) * (x2 - x1))) <= 0) {\\n\\t\\t\\treturn;\\n\\t\\t}\\n\\n\\t\\tDraw3D.clipX = false;\\n\\n\\t\\t// It's possible for a single triangle to be clipped into two separate triangles.\\n\\n\\t\\tif (elements == 3) {\\n\\t\\t\\tif ((x0 < 0) || (x1 < 0) || (x2 < 0) || (x0 > Draw2D.boundX) || (x1 > Draw2D.boundX) || (x2 > Draw2D.boundX)) {\\n\\t\\t\\t\\tDraw3D.clipX = true;\\n\\t\\t\\t}\\n\\n\\t\\t\\tint type;\\n\\n\\t\\t\\tif (faceInfo == null) {\\n\\t\\t\\t\\ttype = 0;\\n\\t\\t\\t} else {\\n\\t\\t\\t\\ttype = faceInfo[face] & 3;\\n\\t\\t\\t}\\n\\n\\t\\t\\tif (type == 0) {\\n\\t\\t\\t\\tDraw3D.fillGouraudTriangle(y0, y1, y2, x0, x1, x2, clippedColor[0], clippedColor[1], clippedColor[2]);\\n\\t\\t\\t} else if (type == 1) {\\n\\t\\t\\t\\tDraw3D.fillTriangle(y0, y1, y2, x0, x1, x2, palette[faceColorA[face]]);\\n\\t\\t\\t} else if (type == 2) {\\n\\t\\t\\t\\tint texturedFace = faceInfo[face] >> 2;\\n\\t\\t\\t\\tint tA = texturedVertexA[texturedFace];\\n\\t\\t\\t\\tint tB = texturedVertexB[texturedFace];\\n\\t\\t\\t\\tint tC = texturedVertexC[texturedFace];\\n\\t\\t\\t\\tDraw3D.fillTexturedTriangle(y0, y1, y2, x0, x1, x2, clippedColor[0], clippedColor[1], clippedColor[2], vertexViewSpaceX[tA], vertexViewSpaceX[tB], vertexViewSpaceX[tC], vertexViewSpaceY[tA], vertexViewSpaceY[tB], vertexViewSpaceY[tC], vertexViewSpaceZ[tA], vertexViewSpaceZ[tB], vertexViewSpaceZ[tC], faceColor[face]);\\n\\t\\t\\t} else if (type == 3) {\\n\\t\\t\\t\\tint texturedFace = faceInfo[face] >> 2;\\n\\t\\t\\t\\tint tA = texturedVertexA[texturedFace];\\n\\t\\t\\t\\tint tB = texturedVertexB[texturedFace];\\n\\t\\t\\t\\tint tC = texturedVertexC[texturedFace];\\n\\t\\t\\t\\tDraw3D.fillTexturedTriangle(y0, y1, y2, x0, x1, x2, faceColorA[face], faceColorA[face], faceColorA[face], vertexViewSpaceX[tA], vertexViewSpaceX[tB], vertexViewSpaceX[tC], vertexViewSpaceY[tA], vertexViewSpaceY[tB], vertexViewSpaceY[tC], vertexViewSpaceZ[tA], vertexViewSpaceZ[tB], vertexViewSpaceZ[tC], faceColor[face]);\\n\\t\\t\\t}\\n\\t\\t} else if (elements == 4) {\\n\\t\\t\\tif ((x0 < 0) || (x1 < 0) || (x2 < 0) || (x0 > Draw2D.boundX) || (x1 > Draw2D.boundX) || (x2 > Draw2D.boundX) || (clippedX[3] < 0) || (clippedX[3] > Draw2D.boundX)) {\\n\\t\\t\\t\\tDraw3D.clipX = true;\\n\\t\\t\\t}\\n\\n\\t\\t\\tint type;\\n\\n\\t\\t\\tif (faceInfo == null) {\\n\\t\\t\\t\\ttype = 0;\\n\\t\\t\\t} else {\\n\\t\\t\\t\\ttype = faceInfo[face] & 3;\\n\\t\\t\\t}\\n\\n\\t\\t\\tif (type == 0) {\\n\\t\\t\\t\\tDraw3D.fillGouraudTriangle(y0, y1, y2, x0, x1, x2, clippedColor[0], clippedColor[1], clippedColor[2]);\\n\\t\\t\\t\\tDraw3D.fillGouraudTriangle(y0, y2, clippedY[3], x0, x2, clippedX[3], clippedColor[0], clippedColor[2], clippedColor[3]);\\n\\t\\t\\t} else if (type == 1) {\\n\\t\\t\\t\\tint colorA = palette[faceColorA[face]];\\n\\t\\t\\t\\tDraw3D.fillTriangle(y0, y1, y2, x0, x1, x2, colorA);\\n\\t\\t\\t\\tDraw3D.fillTriangle(y0, y2, clippedY[3], x0, x2, clippedX[3], colorA);\\n\\t\\t\\t} else if (type == 2) {\\n\\t\\t\\t\\tint texturedFace = faceInfo[face] >> 2;\\n\\t\\t\\t\\tint tA = texturedVertexA[texturedFace];\\n\\t\\t\\t\\tint tB = texturedVertexB[texturedFace];\\n\\t\\t\\t\\tint tC = texturedVertexC[texturedFace];\\n\\t\\t\\t\\tDraw3D.fillTexturedTriangle(y0, y1, y2, x0, x1, x2, clippedColor[0], clippedColor[1], clippedColor[2], vertexViewSpaceX[tA], vertexViewSpaceX[tB], vertexViewSpaceX[tC], vertexViewSpaceY[tA], vertexViewSpaceY[tB], vertexViewSpaceY[tC], vertexViewSpaceZ[tA], vertexViewSpaceZ[tB], vertexViewSpaceZ[tC], faceColor[face]);\\n\\t\\t\\t\\tDraw3D.fillTexturedTriangle(y0, y2, clippedY[3], x0, x2, clippedX[3], clippedColor[0], clippedColor[2], clippedColor[3], vertexViewSpaceX[tA], vertexViewSpaceX[tB], vertexViewSpaceX[tC], vertexViewSpaceY[tA], vertexViewSpaceY[tB], vertexViewSpaceY[tC], vertexViewSpaceZ[tA], vertexViewSpaceZ[tB], vertexViewSpaceZ[tC], faceColor[face]);\\n\\t\\t\\t} else if (type == 3) {\\n\\t\\t\\t\\tint texturedFace = faceInfo[face] >> 2;\\n\\t\\t\\t\\tint tA = texturedVertexA[texturedFace];\\n\\t\\t\\t\\tint tB = texturedVertexB[texturedFace];\\n\\t\\t\\t\\tint tC = texturedVertexC[texturedFace];\\n\\t\\t\\t\\tDraw3D.fillTexturedTriangle(y0, y1, y2, x0, x1, x2, faceColorA[face], faceColorA[face], faceColorA[face], vertexViewSpaceX[tA], vertexViewSpaceX[tB], vertexViewSpaceX[tC], vertexViewSpaceY[tA], vertexViewSpaceY[tB], vertexViewSpaceY[tC], vertexViewSpaceZ[tA], vertexViewSpaceZ[tB], vertexViewSpaceZ[tC], faceColor[face]);\\n\\t\\t\\t\\tDraw3D.fillTexturedTriangle(y0, y2, clippedY[3], x0, x2, clippedX[3], faceColorA[face], faceColorA[face], faceColorA[face], vertexViewSpaceX[tA], vertexViewSpaceX[tB], vertexViewSpaceX[tC], vertexViewSpaceY[tA], vertexViewSpaceY[tB], vertexViewSpaceY[tC], vertexViewSpaceZ[tA], vertexViewSpaceZ[tB], vertexViewSpaceZ[tC], faceColor[face]);\\n\\t\\t\\t}\\n\\t\\t}\\n\\t}\",\n \"private static double[] makePolygon() {\\n double[] polygon = new double[POINTS*2];\\n \\n for (int i = 0; i < POINTS; i++) {\\n double a = i * Math.PI * 2.0 / POINTS;\\n polygon[2*i] = Math.cos(a);\\n polygon[2*i+1] = Math.sin(a);\\n }\\n \\n return polygon;\\n }\",\n \"private Mesh createMesh(final int pTrianglesCount) {\\n\\t\\tfinal int pSpeed \\t\\t\\t= 20;\\n\\t\\tfinal int pVertexCount\\t \\t= Mesh.VERTEX_SIZE * pTrianglesCount * 3; \\t\\n\\t\\tfinal float pColor \\t\\t\\t= new Color(0f,0f,0f).getABGRPackedFloat();\\n\\t\\tfinal float pSegmentWidth \\t= CAMERA_WIDTH/pTrianglesCount;\\n\\t\\tfinal float[] pBufferData \\t= new float[pVertexCount];\\t\\n\\t\\t\\n\\t\\tmHeightOffsetCurrent = new float[pVertexCount];\\t\\t\\n\\t\\t\\n\\t\\t//create triangles \\n\\t\\t// A--B\\n\\t\\t// \\\\ |\\n\\t\\t// \\\\|\\n\\t\\t// C\\n\\t\\t//\\n\\t\\tint i = 0;\\n\\t\\tfloat x = 0f;\\n\\t\\tfinal float pInitialHeight = 400;\\n\\t\\tfor (int triangleIndex = 0;triangleIndex0){ \\n//\\t\\t\\t\\t\\t\\t\\tmHeightOffsetCurrent[i] = mHeightOffsetCurrent[i-2];\\n//\\t\\t\\t\\t\\t\\t} else { \\n//\\t\\t\\t\\t\\t\\t\\tmHeightOffsetCurrent[i] = getNormalizedSine(i+progress_x, mTouchY, pTrianglesCount*3);\\n//\\t\\t\\t\\t\\t\\t}\\n//\\t\\t\\t\\t\\t} \\n//\\t\\t\\t\\t\\tpBuff[(i * Mesh.VERTEX_SIZE) + Mesh.VERTEX_INDEX_Y] = mHeightOffsetCurrent[i];\\n//\\t\\t\\t\\t}\\n//\\t\\t\\t}\\n//\\t\\t\\t\\n//\\t\\t\\tfloat getNormalizedSine(float x, float halfY, float maxX) {\\t\\n//\\t\\t\\t double factor = (2 * Math.PI) / maxX;\\n//\\t\\t\\t return (float) ((Math.sin(x * factor) * halfY) + halfY);\\n//\\t\\t\\t}\\n//\\t\\t\\t\\n//\\t\\t};\\n\\t\\treturn pMesh;\\n\\t}\",\n \"public void circulos() {\\n pushMatrix();\\n translate(width/2, height/2);\\n rotate(-h);\\n noFill();\\n strokeWeight(5);\\n stroke(255);\\n ellipse(10, 10, 20, 20);\\n popMatrix();\\n\\n h = h + 0.3f;\\n }\",\n \"public void zeichneQuadrate(){\\n for (int i=0; i<10;i++)\\n rect (50+i*25,50,25,25);\\n }\",\n \"private Node createVirtualWorldBoundsShape() {\\n \\t\\tPoint3d lower = new Point3d();\\n \\t\\tPoint3d upper = new Point3d();\\n \\t\\tmyVirtualWorldBounds.getLower(lower);\\n \\t\\tmyVirtualWorldBounds.getUpper(upper);\\n \\t\\t\\n \\t\\tdouble[] coordinates = { lower.x, lower.y, lower.z, upper.x, lower.y,\\n \\t\\t\\t\\tlower.z, upper.x, lower.y, upper.z, lower.x, lower.y, upper.z,\\n \\t\\t\\t\\tlower.x, upper.y, lower.z, upper.x, upper.y, lower.z, upper.x,\\n \\t\\t\\t\\tupper.y, upper.z, lower.x, upper.y, upper.z };\\n \\t\\t\\n \\t\\tint[] coordinateIndices = { 0, 1, 1, 2, 2, 3, 3, 0, 4, 5, 5, 6, 6, 7,\\n \\t\\t\\t\\t7, 4, 0, 4, 1, 5, 2, 6, 3, 7 };\\n \\t\\t\\n \\t\\tIndexedLineArray geometry = new IndexedLineArray(\\n \\t\\t\\t\\tcoordinates.length / 3, IndexedLineArray.COORDINATES,\\n \\t\\t\\t\\tcoordinateIndices.length);\\n \\t\\t\\n \\t\\tgeometry.setCoordinates(0, coordinates);\\n \\t\\tgeometry.setCoordinateIndices(0, coordinateIndices);\\n \\t\\t\\n \\t\\treturn new Shape3D(geometry);\\n \\t}\",\n \"public QuadMesh\\n (boolean isBeingSplit,\\n Matrix4f cubeMatrix, \\n\\t\\tVector3f color,\\n\\t\\tboolean inAtmosphere, \\n\\t\\tVector3f meshOffset, \\n\\t\\tboolean inFrustum, \\n\\t\\tfloat arcLengthOverSize, \\n\\t\\tVector3f center, \\n\\t\\tfloat intensity, \\n\\t\\tTexture2D Heightmap, \\n\\t\\tString f ,\\n\\t\\tQuadMesh p, \\n\\t\\tVector3f v1, \\n\\t\\tVector3f v2, \\n\\t\\tVector3f v3, \\n\\t\\tVector3f v4,\\n\\t\\tfloat size,\\n\\t\\tint x, \\n\\t\\tint y, \\n\\t\\tboolean hasChildren, \\n\\t\\tArrayList children, \\n\\t\\tBoundingSphere sphere, \\n\\t\\tGeometry mesh, \\n\\t\\tVector3f faceIndex, \\n\\t\\tfloat centerOff,\\n\\t\\tGeometry bsp)\\t\\n{\\n\\t\\tfirst = v1;\\n\\t\\tsecond = v2;\\n\\t\\tthird = v3;\\n\\t\\tfourth = v4;\\n\\t\\twidth = size;\\n\\t\\tindex1 = x;\\n\\t\\tindex2 = y;\\n\\t\\tthis.hasChildren = hasChildren;\\n\\t\\tthis.children = children;\\n\\t\\tparent = p;\\n\\t\\tface = f;\\n\\t\\tthis.sphere = sphere;\\n\\t\\tthis.mesh = mesh;\\n\\t\\tthis.faceIndex = faceIndex;\\n\\t\\tthis.centerOff = centerOff;\\n\\t\\tthis.Heightmap = Heightmap;\\n\\t\\tthis.intensity = intensity;\\n\\t\\tthis.arcLengthOverSize = arcLengthOverSize;\\n\\t\\tthis.center = center;\\n\\t\\tthis.inFrustum = inFrustum;\\n\\t\\tthis.meshOffset = meshOffset;\\n\\t\\tthis.inAtmosphere = inAtmosphere;\\n\\t\\tthis.color = color;\\n\\t\\tthis.cubeMatrix = cubeMatrix;\\n\\t\\tthis.bsp = bsp;\\n\\n\\t\\n\\t}\",\n \"protected CylinderShade(String name) {\\n\\tsuper(name);\\n }\",\n \"private void createVertices(int iX, int iY, int iXO, int iYO, int num, int increment) {\\n int y = iY;\\n if (num == 0 && increment == 0) {\\n BracketNode last = new BracketNode(\\\"\\\", iX, y - 20, iXO, 20);\\n nodes.add(last);\\n getChildren().addAll(new Line(iX, iY, iX + iXO, iY), last);\\n last.setName(currentBracket.getBracket().get(location));\\n bracketMap.put(last, location);\\n nodeMap.put(location, last);\\n } else {\\n ArrayList aNodeList = new ArrayList<>();\\n for (int i = 0; i < num; i++) {\\n Point2D tl = new Point2D(iX, y);\\n Point2D tr = new Point2D(iX + iXO, y);\\n Point2D bl = new Point2D(iX, y + iYO);\\n Point2D br = new Point2D(iX + iXO, y + iYO);\\n BracketNode nTop = new BracketNode(\\\"\\\", iX, y - 20, iXO, 20);\\n aNodeList.add(nTop);\\n nodes.add(nTop);\\n BracketNode nBottom = new BracketNode(\\\"\\\", iX, y + (iYO - 20), iXO, 20);\\n aNodeList.add(nBottom);\\n nodes.add(nBottom);\\n Line top = new Line(tl.getX(), tl.getY(), tr.getX(), tr.getY());\\n Line bottom = new Line(bl.getX(), bl.getY(), br.getX(), br.getY());\\n Line right = new Line(tr.getX(), tr.getY(), br.getX(), br.getY());\\n getChildren().addAll(top, bottom, right, nTop, nBottom);\\n isTop = !isTop;\\n y += increment;\\n }\\n ArrayList tmpHelp = helper(location, num);\\n for (int j = 0; j < aNodeList.size(); j++) {\\n //System.out.println(currentBracket.getBracket().get(tmpHelp.get(j)));\\n aNodeList.get(j).setName(currentBracket.getBracket().get(tmpHelp.get(j)));\\n bracketMap.put(aNodeList.get(j), tmpHelp.get(j));\\n nodeMap.put(tmpHelp.get(j), aNodeList.get(j));\\n //System.out.println(bracketMap.get(aNodeList.get(j)));\\n }\\n }\\n\\n }\",\n \"public static void main(String[] args){\\n Mesh3D box = Mesh3D.box(10, 20, 60);\\n \\n Line3D lineX = box.getLineX();\\n Line3D lineY = box.getLineY();\\n Line3D lineZ = box.getLineZ();\\n lineX.show();\\n lineY.show();\\n lineZ.show();\\n box.translateXYZ(100, 0.0, 0.0); \\n box.show();\\n Line3D line = new Line3D(); \\n List intersects = new ArrayList();\\n \\n for(int p = 0; p < 100; p++){\\n double r = 600;\\n double theta = Math.toRadians(90.0);//Math.toRadians(Math.random()*180.0);\\n double phi = Math.toRadians(Math.random()*360.0-180.0);\\n line.set(0.0,0.0,0.0, \\n Math.sin(theta)*Math.cos(phi)*r,\\n Math.sin(theta)*Math.sin(phi)*r,\\n Math.cos(theta)*r\\n );\\n intersects.clear();\\n box.intersectionRay(line, intersects);\\n System.out.println(\\\"theta/phi = \\\" + Math.toDegrees(theta) + \\\" \\\"\\n + Math.toDegrees(phi) + \\\" intersects = \\\" + intersects.size());\\n \\n }\\n }\",\n \"public void texturedSphere(float r, PGraphics t) {\\n int v1,v11,v2;\\n r = (r + 240 ) * 0.33f;\\n beginShape(TRIANGLE_STRIP);\\n texture(t);\\n float iu=(float)(t.width-1)/(sDetail);\\n float iv=(float)(t.height-1)/(sDetail);\\n float u=0,v=iv;\\n for (int i = 0; i < sDetail; i++) {\\n vertex(0, -r, 0,u,0);\\n vertex(sphereX[i]*r, sphereY[i]*r, sphereZ[i]*r, u, v);\\n u+=iu;\\n }\\n vertex(0, -r, 0,u,0);\\n vertex(sphereX[0]*r, sphereY[0]*r, sphereZ[0]*r, u, v);\\n endShape(); \\n \\n // Middle rings\\n int voff = 0;\\n for(int i = 2; i < sDetail; i++) {\\n v1=v11=voff;\\n voff += sDetail;\\n v2=voff;\\n u=0;\\n beginShape(TRIANGLE_STRIP);\\n texture(t);\\n for (int j = 0; j < sDetail; j++) {\\n vertex(sphereX[v1]*r, sphereY[v1]*r, sphereZ[v1++]*r, u, v);\\n vertex(sphereX[v2]*r, sphereY[v2]*r, sphereZ[v2++]*r, u, v+iv);\\n u+=iu;\\n }\\n \\n // Close each ring\\n v1=v11;\\n v2=voff;\\n vertex(sphereX[v1]*r, sphereY[v1]*r, sphereZ[v1]*r, u, v);\\n vertex(sphereX[v2]*r, sphereY[v2]*r, sphereZ[v2]*r, u, v+iv);\\n endShape();\\n v+=iv;\\n }\\n u=0;\\n \\n // Add the northern cap\\n beginShape(TRIANGLE_STRIP);\\n texture(t);\\n for (int i = 0; i < sDetail; i++) {\\n v2 = voff + i;\\n vertex(sphereX[v2]*r, sphereY[v2]*r, sphereZ[v2]*r, u, v);\\n vertex(0, r, 0,u,v+iv); \\n u+=iu;\\n }\\n vertex(sphereX[voff]*r, sphereY[voff]*r, sphereZ[voff]*r, u, v);\\n endShape();\\n \\n}\"\n]"},"negative_scores":{"kind":"list like","value":["0.74141616","0.7180983","0.6534577","0.6443094","0.6325939","0.62532634","0.6214325","0.61043334","0.6033015","0.5941839","0.5917603","0.5874169","0.5848993","0.5822796","0.5736581","0.5726616","0.57251155","0.56994885","0.56539667","0.56462157","0.56400114","0.5624602","0.56207466","0.5584326","0.5580492","0.55592334","0.5490261","0.54362816","0.5420597","0.5410426","0.541011","0.5403823","0.53638786","0.5322131","0.5259929","0.5258021","0.5252837","0.52526337","0.5226144","0.52191854","0.5157948","0.5156043","0.51514643","0.5144477","0.5129782","0.5112576","0.5075971","0.5066282","0.5054151","0.50246584","0.50175697","0.50041854","0.5002203","0.49955428","0.49725747","0.49715585","0.49585602","0.49533442","0.4946527","0.4945605","0.49449176","0.49327692","0.4919726","0.49065557","0.48894283","0.48743072","0.48677507","0.48677087","0.4866206","0.48491332","0.48415592","0.4840922","0.48356208","0.48341018","0.48139796","0.48090962","0.48020086","0.47966242","0.47881123","0.4785111","0.47845647","0.4782099","0.47816843","0.47790673","0.47750837","0.4769757","0.47647396","0.47645688","0.47606674","0.4759291","0.47563857","0.47537315","0.47533187","0.47438967","0.47274634","0.4715286","0.47141683","0.47140533","0.4681698","0.46786597"],"string":"[\n \"0.74141616\",\n \"0.7180983\",\n \"0.6534577\",\n \"0.6443094\",\n \"0.6325939\",\n \"0.62532634\",\n \"0.6214325\",\n \"0.61043334\",\n \"0.6033015\",\n \"0.5941839\",\n \"0.5917603\",\n \"0.5874169\",\n \"0.5848993\",\n \"0.5822796\",\n \"0.5736581\",\n \"0.5726616\",\n \"0.57251155\",\n \"0.56994885\",\n \"0.56539667\",\n \"0.56462157\",\n \"0.56400114\",\n \"0.5624602\",\n \"0.56207466\",\n \"0.5584326\",\n \"0.5580492\",\n \"0.55592334\",\n \"0.5490261\",\n \"0.54362816\",\n \"0.5420597\",\n \"0.5410426\",\n \"0.541011\",\n \"0.5403823\",\n \"0.53638786\",\n \"0.5322131\",\n \"0.5259929\",\n \"0.5258021\",\n \"0.5252837\",\n \"0.52526337\",\n \"0.5226144\",\n \"0.52191854\",\n \"0.5157948\",\n \"0.5156043\",\n \"0.51514643\",\n \"0.5144477\",\n \"0.5129782\",\n \"0.5112576\",\n \"0.5075971\",\n \"0.5066282\",\n \"0.5054151\",\n \"0.50246584\",\n \"0.50175697\",\n \"0.50041854\",\n \"0.5002203\",\n \"0.49955428\",\n \"0.49725747\",\n \"0.49715585\",\n \"0.49585602\",\n \"0.49533442\",\n \"0.4946527\",\n \"0.4945605\",\n \"0.49449176\",\n \"0.49327692\",\n \"0.4919726\",\n \"0.49065557\",\n \"0.48894283\",\n \"0.48743072\",\n \"0.48677507\",\n \"0.48677087\",\n \"0.4866206\",\n \"0.48491332\",\n \"0.48415592\",\n \"0.4840922\",\n \"0.48356208\",\n \"0.48341018\",\n \"0.48139796\",\n \"0.48090962\",\n \"0.48020086\",\n \"0.47966242\",\n \"0.47881123\",\n \"0.4785111\",\n \"0.47845647\",\n \"0.4782099\",\n \"0.47816843\",\n \"0.47790673\",\n \"0.47750837\",\n \"0.4769757\",\n \"0.47647396\",\n \"0.47645688\",\n \"0.47606674\",\n \"0.4759291\",\n \"0.47563857\",\n \"0.47537315\",\n \"0.47533187\",\n \"0.47438967\",\n \"0.47274634\",\n \"0.4715286\",\n \"0.47141683\",\n \"0.47140533\",\n \"0.4681698\",\n \"0.46786597\"\n]"},"document_score":{"kind":"string","value":"0.7465177"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":4694,"cells":{"query":{"kind":"string","value":"Stretches the geometry parallel to the object space axes"},"document":{"kind":"string","value":"public void scale(double xScale, double yScale, double zScale) {\n\t\t// Create a matrix that will transform vertices to their new positions\n\t\tMatrix scaleMatrix = new Matrix(3, 3);\n\t\tscaleMatrix.setElement(0, 0, xScale);\n\t\tscaleMatrix.setElement(1, 1, yScale);\n\t\tscaleMatrix.setElement(2, 2, zScale);\n\t\tfor (int i = 0; i < verts.length; i++) {\n\t\t\tverts[i] = scaleMatrix.multiply(verts[i]);\n\t\t}\n\t}"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["private void setSizeBox() {\n\t\t\tthis.leftX = pointsSubStroke.get(0).getX();\n\t\t\tthis.righX = pointsSubStroke.get(0).getX();\n\t\t\tthis.topY = pointsSubStroke.get(0).getY();\n\t\t\tthis.bottomY = pointsSubStroke.get(0).getY();\n\t\t\t\n\t\t\tfor(int i = 0; i < pointsSubStroke.size();i++) {\n\t\t\t\tdouble x = pointsSubStroke.get(i).getX();\n\t\t\t\tdouble y = pointsSubStroke.get(i).getX();\n\t\t\t\t\n\t\t\t\tthis.leftX = Math.min(x, leftX);\n\t\t\t\tthis.righX = Math.max(x, righX);\n\t\t\t\tthis.topY = Math.min(y, topY);\n\t\t\t\tthis.bottomY = Math.max(y, bottomY);\n\t\t\t}\n\t\t}","public void updateTransform() {\n \t\tif (viewBox != null) {\n \t\t\tOMSVGRect bbox = ((SVGRectElement)viewBox.getElement()).getBBox();\n //\t\t\tGWT.log(\"bbox = \" + bbox.getDescription());\n \t\t\tfloat d = (float)Math.sqrt((bbox.getWidth() * bbox.getWidth() + bbox.getHeight() * bbox.getHeight()) * 0.25) * scale * 2;\n //\t\t\tGWT.log(\"d = \" + d);\n \t\t\n \t\t\t// Compute the actual canvas size. It is the max of the window rect\n \t\t\t// and the transformed bbox.\n \t\t\tfloat width = Math.max(d, windowRect.getWidth());\n \t\t\tfloat height = Math.max(d, windowRect.getHeight());\n //\t\t\tGWT.log(\"width = \" + width);\n //\t\t\tGWT.log(\"height = \" + height);\n \n \t\t\t// Compute the display transform to center the image in the\n \t\t\t// canvas\n \t\t\tOMSVGMatrix m = svg.createSVGMatrix();\n \t\t\tfloat cx = bbox.getCenterX();\n \t\t\tfloat cy = bbox.getCenterY();\n \t\t\tm = m.translate(0.5f * (width - bbox.getWidth()) -bbox.getX(), 0.5f * (height - bbox.getHeight()) -bbox.getY())\n \t\t\t.translate(cx, cy)\n \t\t\t.rotate(angle)\n \t\t\t.scale(scale)\n \t\t\t.translate(-cx, -cy);\n \t\t\t((ISVGTransformable)xformGroup).getTransform().getBaseVal().getItem(0).setMatrix(m);\n \t\t\t((ISVGTransformable)modelGroup.getTwinWrapper()).getTransform().getBaseVal().getItem(0).setMatrix(m);\n //\t\t\tGWT.log(\"m=\" + m.getDescription());\n \t\t\tsvg.getStyle().setWidth(width, Unit.PX);\n \t\t\tsvg.getStyle().setHeight(height, Unit.PX);\n \t\t}\n \t}","public void transform() {\n final var bounds = getParentBounds();\n transform( bounds.width, bounds.height );\n }","private void updateViewBounds() \r\n {\r\n assert !sim.getMap().isEmpty() : \"Visualiser needs simulator whose a map has at least one node\"; \r\n \r\n \r\n viewMinX = minX * zoomFactor;\r\n viewMinY = minY * zoomFactor;\r\n \r\n viewMaxX = maxX * zoomFactor;\r\n viewMaxY = maxY * zoomFactor;\r\n \r\n \r\n double marginLength = zoomFactor * maxCommRange;\r\n \r\n \r\n // Set the size of the component\r\n int prefWidth = (int)Math.ceil( (viewMaxX - viewMinX) + (marginLength * 2) );\r\n int prefHeight = (int)Math.ceil( (viewMaxY - viewMinY) + (marginLength * 2) );\r\n setPreferredSize( new Dimension( prefWidth, prefHeight ) );\r\n \r\n \r\n // Adjust for margin lengths \r\n viewMinX -= marginLength;\r\n viewMinY -= marginLength;\r\n \r\n viewMaxX += marginLength;\r\n viewMaxY += marginLength;\r\n }","@Override\n public void componentResized(ComponentEvent e) {\n setShape(new Ellipse2D.Double(0,0,FRAME_WIDTH,FRAME_WIDTH));\n }","public void updateBounds() {\n this.setBounds(left, top, width, height);\n }","private void updateSize() {\n double width = pane.getWidth();\n double height = pane.getHeight();\n\n if(oldWidth == 0) {\n oldWidth = width;\n }\n if(oldHeight == 0) {\n oldHeight = height;\n }\n\n double oldHvalue = pane.getHvalue();\n double oldVvalue = pane.getVvalue();\n if(Double.isNaN(oldVvalue)) {\n oldVvalue = 0;\n }\n if(Double.isNaN(oldHvalue)) {\n oldHvalue = 0;\n }\n\n pane.setVmax(height);\n pane.setHmax(width);\n\n if(grow) {\n renderMapGrow(width, height, curZoom);\n } else {\n renderMap(width, height, curZoom);\n }\n\n pane.setVvalue((height/oldHeight)*oldVvalue);\n pane.setHvalue((width/oldWidth)*oldHvalue);\n\n oldWidth = width;\n oldHeight = height;\n }","@Override\n\tpublic void componentResized(ComponentEvent e) {\n\t\twidthAttitude=e.getComponent().getSize().getWidth()/Width;\n\t\theightAttitude=e.getComponent().getSize().getHeight()/Height;\n\t}","public void onBoundsResolved()\n {\n updateTransform();\n }","public void expand(){\n\t\tsetBounds(getX()-getWidth()/4, getY(), getWidth() * 1.5f, getHeight());\n\t\tcollisionBounds.setWidth(getWidth());\n\t}","public void setFrameSize(double aWidth, double aHeight)\n{\n // If shape not rotated, scaled or skewed, just set and return\n if(!isRSS()) {\n if(_width<0) { setX(_x + (aWidth+_width)); aWidth = -aWidth; }\n if(_height<0) { setY(_y + (aHeight+_height)); aHeight = -aHeight; }\n setSize(aWidth, aHeight); return;\n }\n \n // Convert X & Y axis to parent coords\n RMSize x_axis = convertVectorToShape(new RMSize(_width, 0), _parent);\n RMSize y_axis = convertVectorToShape(new RMSize(0, _height), _parent);\n\n // Scale widths of X & Y axes in parent coords by ratio of NewWidth/OldWidth\n double sizeByRatio1 = Math.abs(aWidth)/(Math.abs(x_axis.width) + Math.abs(y_axis.width));\n x_axis.width *= sizeByRatio1; y_axis.width *= sizeByRatio1;\n \n // Scale heights of X & Y axes in parent coords by ratio of NewHeight/OldHeight\n double sizeByRatio2 = Math.abs(aHeight)/(Math.abs(x_axis.height) + Math.abs(y_axis.height));\n x_axis.height *= sizeByRatio2; y_axis.height *= sizeByRatio2;\n\n // Cache current bounds origin (this shouldn't change)\n RMPoint origin = getFrameXY();\n \n // Reset current Skew and convert X & Y axis from parent coords\n setSkewXY(0, 0);\n convertVectorFromShape(x_axis, _parent);\n convertVectorFromShape(y_axis, _parent);\n\n // Set the size to compensate for the skew\n setSize(x_axis.width, y_axis.height);\n\n // Calculate new skew angles (or roll, if width or height is zero)\n if(width()==0)\n setRoll(getRoll() - Math.toDegrees(Math.atan(y_axis.width/y_axis.height)));\n else if(height()==0)\n setRoll(getRoll() - Math.toDegrees(Math.atan(x_axis.height/x_axis.width)));\n else {\n setSkewX(Math.toDegrees(Math.atan(x_axis.height/x_axis.width)));\n setSkewY(Math.toDegrees(Math.atan(y_axis.width/y_axis.height)));\n }\n\n // Reset original bounds origin (it may have been effected by skew changes)\n setFrameXY(origin);\n}","private void reCalculateFullExtent(){\r\n\t\tif (graphics.size() > 0) {\r\n\t\t\tFGraphic g = (FGraphic) graphics.get(0);\r\n\t\t\tfullExtent = g.getGeom().getEnvelope();\r\n\t\t\tfor (int i = 1; i < graphics.size(); i++) {\r\n\t\t\t\tg = (FGraphic) graphics.get(i);\r\n\t\t\t\tEnvelope rAux = g.getGeom().getEnvelope();\r\n\r\n\t\t\t\tfullExtent.add(rAux);\r\n\t\t\t}\r\n\t\t}\r\n\t}","@Override\n public void onSizeChanged(int w, int h, int oldW, int oldH) {\n // Set the movement bounds for the ballParent\n box.set(0, 0, w, h);\n }","@Override\npublic void basicDisplayBox(Point origin, Point corner) {\n // do nothing\n // we could transform all components proportionally\n}","private void updateBoxes(){\n if(model.getMap() != null) {\n DoubleVec position = invModelToView(new DoubleVec(canvas.getWidth()*0.5,canvas.getHeight()*0.5));\n inner = new Rectangle(position, 1.0/zoomFactor * fi * canvas.getWidth(), 1.0/zoomFactor * fi * canvas.getHeight(), 0);\n outer = new Rectangle(position, 1.0/zoomFactor * fo * canvas.getWidth(), 1.0/zoomFactor * fo * canvas.getHeight(), 0);\n }\n }","public void zoomToAreaOfInterest() {\n Envelope aoe = context.getViewport().getBounds();\n if (aoe.getWidth() == 0) {\n aoe.expandBy(.001, 0);\n }\n\n if (aoe.getHeight() == 0) {\n aoe.expandBy(0, .001);\n }\n Rectangle2D rect = new Rectangle2D.Double(aoe.getMinX(), aoe.getMinY(),\n aoe.getWidth(), aoe.getHeight());\n getCamera().animateViewToCenterBounds(rect, true, 0);\n }","Geometry getGeometry();","@SuppressWarnings(\"unchecked\")\n public void centralizarComponente() {\n Dimension ds = Toolkit.getDefaultToolkit().getScreenSize();\n Dimension dw = getSize();\n setLocation((ds.width - dw.width) / 2, (ds.height - dw.height) / 2);\n }","@Override\r\n\tprotected void onSizeChanged(int w, int h, int oldw, int oldh) {\n\t\tfloat xPad = getPaddingLeft() + getPaddingRight();\r\n\t\tfloat yPad = getPaddingTop() + getPaddingBottom();\r\n\t\tdimension = Math.min(w - xPad, (h - yPad) * 2);\r\n\t\tradius = 60;\r\n\t\tinsideLeft = w / 2 - radius;\r\n\t\tinsideRight = w / 2 + radius;\r\n\t\tinsideTop = dimension - getPaddingBottom() - radius;\r\n\t\tinsideBottom = dimension - getPaddingBottom();\r\n\t\t\r\n//\t\toutRect = new RectF(getPaddingLeft(), getPaddingTop(), dimension - getPaddingRight(), dimension - getPaddingBottom());\r\n//\t\toutRect = new RectF(getPaddingLeft(), getPaddingTop(), dimension - getPaddingRight(), dimension/2);\r\n//\t\toutRect = new RectF(getPaddingLeft(), getPaddingTop(), dimension, dimension);\r\n\t\toutRect = new RectF(getPaddingLeft(), getPaddingTop(), w-getPaddingRight(), h-getPaddingBottom());\r\n\t\tfloat insideRectDownH = dimension-getPaddingBottom()-getPaddingTop()+150;\r\n//\t\tinsideRect = new RectF(50, 300, 320, insideRectDownH);\r\n\t\tinsideRect = new RectF(w/2-radius, dimension-radius, w/2+radius, dimension+radius);\r\n\t}","public void scaleAffine(){\n //Get the monitors size.\n Dimension screenSize = Toolkit.getDefaultToolkit().getScreenSize();\n transform = new AffineTransform();\n double width = screenSize.getWidth();\n double height = screenSize.getHeight();\n\n //Set up the scale amount for our Affinetransform\n double xscale = width / model.getBbox().getWidth();\n double yscale = height / model.getBbox().getHeight();\n\n double scale = max(xscale, yscale);\n\n adjustZoomLvl(scale);\n transform.translate(-model.getBbox().getMinX(), -model.getBbox().getMaxY());\n\n bounds = new CanvasBounds(getBounds(), transform);\n adjustZoomFactor();\n }","protected void resizePanel() {\n\t\tif (drawingAreaIsBlank) { // may have become blank after deleting the last node manually, so panel must still be shrunk\n\t\t\tsetPreferredSize(new Dimension(0,0)); // put back to small size so scrollbars disappear\n\t\t\trevalidate();\n\t\t\treturn;\n\t\t}\n\t\tgetMaxMin(); // get the extent of the tree to the left, right, bottom\n\t\tsetPreferredSize(new Dimension(maxX, maxY));\n\t\trevalidate();\n\t}","@Override\n\tpublic void reshape(GLAutoDrawable glDrawable, int x, int y, int width, int height) {\n\t\tGL2 gl = glDrawable.getGL().getGL2();\n\t\t\n\t\t// resize the ortho view\n\t\t\n\t\t// set the matrix mode to projection\n\t\tgl.glMatrixMode(GL2.GL_PROJECTION);\n\t\t// initialize the matrix\n\t\tgl.glLoadIdentity();\n\t\t// set the view to a 2D view\n\t\tgl.glOrtho(-width / 2.0, width / 2.0, -height / 2.0, height / 2.0, 0, 1);\n\t\t\n\t\t// switch to the model view matrix\n\t\tgl.glMatrixMode(GL2.GL_MODELVIEW);\n\t\t// initialize the matrix\n\t\tgl.glLoadIdentity();\n\t\t\n\t\t// set the size\n\t\tthis.size = new Dimension(width, height);\n\t}","@Override\n public void reshape(GLAutoDrawable drawable, int x, int y, int width, int height) {\n GL2 gl = drawable.getGL().getGL2(); // get the OpenGL 2 graphics context\n\n if (height == 0) height = 1; // prevent divide by zero\n double aspect = (double)width / height;\n\n // Set the view port (display area) to cover the entire window\n gl.glViewport(0, 0, width, height);\n\n // Setup perspective projection, with aspect ratio matches viewport\n gl.glMatrixMode(GL_PROJECTION); // choose projection matrix\n gl.glLoadIdentity(); // reset projection matrix\n glu.gluPerspective(45.0, aspect, 0.1, 100.0); // fovy, aspect, zNear, zFar\n\n // Enable the model-view transform\n gl.glMatrixMode(GL_MODELVIEW);\n gl.glLoadIdentity(); // reset\n }","public void zoomToFit(RTGraphComponent.RenderContext myrc) {\n RTGraphComponent.RenderContext original_myrc = myrc;\n // Get the render context\n if (myrc == null) myrc = (RTGraphComponent.RenderContext) (getRTComponent().getRTRenderContext()); if (myrc == null) return;\n // Go through the entities... may be faster to iterate over visible entities...\n Iterator it = entity_to_wxy.keySet().iterator(); if (it.hasNext() == false) return;\n double x0 = Double.POSITIVE_INFINITY, y0 = Double.POSITIVE_INFINITY,\n x1 = Double.NEGATIVE_INFINITY, y1 = Double.NEGATIVE_INFINITY;\n // Check bounds for each one and adjust mins/maxes as appropriate\n while (it.hasNext()) { \n String str = it.next(); if (myrc.visible_entities.contains(str) == false) continue;\n if (x0 > entity_to_wxy.get(str).getX()) x0 = entity_to_wxy.get(str).getX();\n if (y0 > entity_to_wxy.get(str).getY()) y0 = entity_to_wxy.get(str).getY();\n if (x1 < entity_to_wxy.get(str).getX()) x1 = entity_to_wxy.get(str).getX();\n if (y1 < entity_to_wxy.get(str).getY()) y1 = entity_to_wxy.get(str).getY();\n }\n // Validate the output\n if (Double.isInfinite(x0) || Double.isInfinite(y0)) return;\n // Give it a border\n if (x1 == x0) x1 = x0 + 0.5; if (y1 == y0) y1 = y0 + 0.5;\n double xp = (x1 - x0)*0.05, yp = (y1 - y0)*0.05;\n // Transform and redraw\n if (getGraphBG() == GraphBG.GEO_OUT || getGraphBG() == GraphBG.GEO_FILL || getGraphBG() == GraphBG.GEO_TOUCH) {\n if (x0 > -180) { x0 = -180; xp = 0.0; }\n if (y0 > -90) { y0 = -90; yp = 0.0; }\n if (x1 < 180) { x1 = 180; xp = 0.0; }\n if (y1 < 90) { y1 = 90; yp = 0.0; }\n }\n extents = new Rectangle2D.Double(x0-xp,y0-yp,x1-x0+2*xp,y1-y0+2*yp);\n transform(); if (original_myrc == null) getRTComponent().render();\n }","void setBounds(double x, double y, double scale) {\n double drawAspect = (double)width / (double)height;\n\n double halfPlotWidth = scale / 2.0;\n double halfPlotHeight = scale / 2.0;\n if (drawAspect > 1.0) {\n halfPlotWidth *= drawAspect;\n } else {\n halfPlotHeight /= drawAspect;\n }\n\n setBounds(x - halfPlotWidth, y - halfPlotHeight, x + halfPlotWidth, y + halfPlotHeight);\n }","private void drag() {\n Point mousePosition = calculateMouseLocation();\n getArea().x = mousePosition.getX() - (mouseX - prevX);\n getArea().y = mousePosition.getY() - (mouseY - prevY);\n // Ensure that weird resizing stuff doesn't happen while moving the\n // window. Idfk why this works, but it does.\n resize();\n getLayout().resize(this, getChildren());\n getLayout().layout(this, getChildren());\n }","public void reshape(int x, int y, int w, int h) {\n size.width = w;\n size.height = h;\n }","protected Rectangle getSelectedElementFigureArea()\n {\n boolean anchored = false;\n\n // Use figures since they may be sized differently during dynamics\n // accumulate as unzoomed.\n Rectangle r = null;\n\n // Go through the list of selected widget figures, union the bounds.\n Iterator> iter = selection.getSelectedFigures();\n\n while (iter.hasNext()) {\n FrameEltSelnFig fig = iter.next();\n\n if (fig instanceof GraphicalWidget) {\n GraphicalWidget gw = (GraphicalWidget) fig;\n IWidget w = gw.getModel();\n SimpleWidgetGroup wg = w.getParentGroup();\n\n if (wg != null) {\n r = unionBounds(r, getGroupFigureBounds(wg));\n anchored = anchored || (w instanceof ChildWidget);\n }\n else {\n r = unionBounds(r, gw.getBounds());\n }\n }\n else if (fig instanceof FrameEltGroupHalo) {\n Rectangle haloBds = fig.getBounds(); // this is zoomed!\n double scale = frameUI.getZoom();\n\n double right = (haloBds.x + haloBds.width) / scale;\n double bottom = (haloBds.y + haloBds.height) / scale;\n double left = haloBds.x / scale;\n double top = haloBds.y / scale;\n\n haloBds =\n PrecisionUtilities.getDraw2DRectangle(left,\n top,\n right - left,\n bottom - top);\n\n r = unionBounds(r, haloBds);\n }\n }\n\n setTopLeftAnchored(anchored);\n\n return r;\n }","protected void calculateBounds()\r\n {\r\n Toolkit DefaultToolkit = Toolkit.getDefaultToolkit();\r\n Dimension ScreenSize = DefaultToolkit.getScreenSize();\r\n int FrameWidth = ScreenSize.width - 100;\r\n int FrameHeight = ScreenSize.height - 100;\r\n setBounds(50, 50, FrameWidth, FrameHeight);\r\n }","public void updateCoords() {\n line.setLine(parent.getFullBounds().getCenter2D(), child.getFullBounds().getCenter2D());\n Rectangle2D r = line.getBounds2D();\n // adding 1 to the width and height prevents the bounds from\n // being marked as empty and is much faster than createStrokedShape()\n setBounds(r.getX(), r.getY(), r.getWidth() + 1, r.getHeight() + 1);\n invalidatePaint();\n }","@Override\n protected void onSizeChanged (int w, int h, int oldw, int oldh) {\n mXSize = w;\n mYSize = h;\n\n mZBoundOut = new RectF(w/2-w/2.5f, h/2-w/2.5f, w/2+w/2.5f, h/2+w/2.5f);\n mZBoundOut2 = new RectF(\n w/2-w/2.5f-ZRING_CURSOR_ADD, h/2-w/2.5f-ZRING_CURSOR_ADD,\n w/2+w/2.5f+ZRING_CURSOR_ADD, h/2+w/2.5f+ZRING_CURSOR_ADD);\n mZBoundIn = new RectF(\n w/2-w/2.5f+ZRING_WIDTH, h/2-w/2.5f+ZRING_WIDTH,\n w/2+w/2.5f-ZRING_WIDTH, h/2+w/2.5f-ZRING_WIDTH);\n mZBoundIn2 = new RectF(\n w/2-w/2.5f+ZRING_WIDTH+ZRING_CURSOR_ADD, h/2-w/2.5f+ZRING_WIDTH+ZRING_CURSOR_ADD,\n w/2+w/2.5f-ZRING_WIDTH-ZRING_CURSOR_ADD, h/2+w/2.5f-ZRING_WIDTH-ZRING_CURSOR_ADD);\n\n if (LOCAL_LOGV) Log.v(TAG, \"New view size = (\"+w+\", \"+h+\")\");\n }","public void centerSelection() {\n RenderContext myrc = (RenderContext) rc; if (myrc == null) return;\n Set sel = myrc.filterEntities(getRTParent().getSelectedEntities());\n if (sel != null && sel.size() > 0) {\n Iterator it = sel.iterator();\n\twhile (it.hasNext()) { \n\t String ent = it.next(); Point2D point = entity_to_wxy.get(ent);\n\t if (last_shft_down) entity_to_wxy.put(ent, new Point2D.Double(point.getX(),m_wy)); \n\t else if (last_ctrl_down) entity_to_wxy.put(ent, new Point2D.Double(m_wx,point.getY()));\n\t else entity_to_wxy.put(ent, new Point2D.Double(m_wx,m_wy));\n\t transform(ent); \n\t}\n getRTComponent().render();\n }\n }","public void updateBounds(){\r\n\t\tRectangle bounds = new Rectangle(super.getBounds());\r\n\t\tint preferredHeight = 0;\r\n\t\tfor(Object child : getChildren()){\r\n\t\t\tIFigure figure = (IFigure)child;\r\n\t\t\tpreferredHeight += figure.getPreferredSize().height;\r\n\t\t}\r\n\t\tif (preferredHeight == 0) preferredHeight = 200;\r\n\t\tbounds.setHeight(preferredHeight+20);\r\n\t\tsetBounds(bounds);\r\n\t}","public void componentResized(ComponentEvent e) {\n myReshape(getSize().width, getSize().height);\n display();\n repaint();\n }","public void componentResized(ComponentEvent e) {\n myReshape(getSize().width, getSize().height);\n display();\n repaint();\n }","@Override\r\n\tprotected void initShape() {\n\t\tgetPositions().putAll(createSymmetricLines(0, 1.5, .5, 1.1, WingPart.OUTER_LEFT, WingPart.OUTER_RIGHT));\r\n\t\t//->upper corner\r\n\t\tgetPositions().putAll(createSymmetricLines(.5, 1.1, 1, .7, WingPart.OUTER_LEFT, WingPart.OUTER_RIGHT));\r\n\t\t//-> lower outer corner\r\n\t\tgetPositions().putAll(createSymmetricLines(1, .7, 1.1, .3, WingPart.OUTER_LEFT, WingPart.OUTER_RIGHT));\r\n\t\t//-> lower inner corner\r\n\t\tgetPositions().putAll(createSymmetricLines(1.1, .3, .7, .25, WingPart.OUTER_LEFT, WingPart.OUTER_RIGHT));\r\n\t\t//-> middle\r\n\t\tgetPositions().putAll(createSymmetricLines(.7, .25, .2, 1.35, WingPart.OUTER_LEFT, WingPart.OUTER_RIGHT));\r\n\t\t//inner\r\n\t\tgetPositions().putAll(createSymmetricLines(1, .5, .55, 0.95, WingPart.INNER_LEFT, WingPart.INNER_RIGHT));\r\n\t\tgetPositions().putAll(createSymmetricLines(0.8, .4, .55, 0.95, WingPart.INNER_LEFT, WingPart.INNER_RIGHT));\r\n\t\tgetPositions().putAll(createSymmetricPoints(0.9, .5, WingPart.INNER_LEFT, WingPart.INNER_RIGHT));\r\n\r\n//\t\tgetPositions().putAll(fill(WingPart.OUTER_RIGHT, WingPart.INNER_RIGHT));\r\n//\t\tgetPositions().putAll(fill(WingPart.OUTER_LEFT, WingPart.INNER_LEFT));\r\n\t}","@Override\n public void componentResized(ComponentEvent e) {\n window.setShape(new Ellipse2D.Double(0, 0, window.getWidth(), window.getHeight()));\n window.add(panel);\n window.setLocation((screenSize.width - window.getSize().width) / 2, (screenSize.height - window.getSize().height) / 2);\n window.setVisible(true);\n }","public void updateRenderRect() {\n int i = 0;\n if (this.mTargetRatio == 2) {\n this.mTx = this.mRenderWidth == 0 ? 0 : (this.mRenderOffsetX * this.mSurfaceWidth) / this.mRenderWidth;\n int i2 = (this.mSurfaceHeight - this.mSurfaceWidth) / 2;\n if (this.mRenderHeight != 0) {\n i = (this.mRenderOffsetY * this.mSurfaceHeight) / this.mRenderHeight;\n }\n this.mTy = i2 + i;\n this.mTwidth = this.mSurfaceWidth;\n this.mTheight = this.mSurfaceWidth;\n this.mRenderLayoutRect.set(this.mRenderOffsetX, ((this.mRenderHeight - this.mRenderWidth) / 2) + this.mRenderOffsetY, this.mRenderWidth + this.mRenderOffsetX, ((this.mRenderHeight - this.mRenderWidth) / 2) + this.mRenderOffsetY + this.mRenderWidth);\n return;\n }\n this.mTx = this.mRenderWidth == 0 ? 0 : (this.mRenderOffsetX * this.mSurfaceWidth) / this.mRenderWidth;\n this.mTy = this.mRenderHeight == 0 ? 0 : (this.mRenderOffsetY * this.mSurfaceHeight) / this.mRenderHeight;\n this.mTwidth = this.mSurfaceWidth;\n this.mTheight = this.mSurfaceHeight;\n this.mRenderLayoutRect.set(0, 0, this.mRenderWidth, this.mRenderHeight);\n }","public void update() {\n\t\tactSX=parent.actSX*scaleX;\n\t\tactSY=parent.actSY*scaleY;\n\t\tw=posW*actSX;\n\t\th=posH*actSY;\n\t\tswitch (align) {\n\t\tcase DEFAULT:\n\t\t\tx=parent.x+posX*actSX;\n\t\t\ty=parent.y+posY*actSY;\n\t\t\tbreak;\n\t\tcase TOPRIGHT:\n\t\t\tx=parent.x+parent.w-(posX+posW)*actSX;\n\t\t\ty=parent.y+posY*actSY;\n\t\t\tbreak;\n\t\tcase BOTTOMLEFT:\n\t\t\tx=parent.x+posX*actSX;\n\t\t\ty=parent.y+parent.h-(posY+posH)*actSY;\n\t\t\tbreak;\n\t\tcase BOTTOMRIGHT:\n\t\t\tx=parent.x+parent.w-(posX+posW)*actSX;\n\t\t\ty=parent.y+parent.h-(posY+posH)*actSY;\n\t\t\tbreak;\n\t\tcase CENTEREDX:\n\t\t\tx=parent.x+parent.w/2-w/2+posX*actSX;\n\t\t\ty=parent.y+posY*actSY;\n\t\t\tbreak;\n\t\tcase CENTEREDY:\n\t\t\tx=parent.x+posX*actSX;\n\t\t\ty=parent.y+parent.h/2-h/2+posY*actSY;\n\t\t\tbreak;\n\t\tcase CENTEREDXY:\n\t\t\tx=parent.x+parent.w/2-w/2+posX*actSX;\n\t\t\ty=parent.y+parent.h/2-h/2+posY*actSY;\n\t\t\tbreak;\n\t\t}\n\t}","protected void update(Rectangle r)\n {\n if ((r != null) &&\n (bottomRightResize != null) &&\n bottomRightResize.isVisible())\n {\n // Since the resize rects are not drawn in the zoomed area\n // calculate the positions in the unzoomed context\n double scale = frameUI.getZoom();\n\n // Center on corners. These figures are not \"scaled\" they must\n // be positioned in SCALED location, not in 1:1 location.\n double right = r.x + r.width;\n double bottom = r.y + r.height;\n\n int x = PrecisionUtilities.round(r.x * scale);\n int y = PrecisionUtilities.round(r.y * scale);\n int width = PrecisionUtilities.round(right * scale) - x;\n int height = PrecisionUtilities.round(bottom * scale) - y;\n\n // Trigger a redraw on all handles.\n if (topLeftResize.isVisible()) {\n topLeftResize.centerAt(x, y);\n topLeftResize.repaint();\n }\n\n bottomLeftResize.centerAt(x, y + height);\n bottomLeftResize.repaint();\n\n topRightResize.centerAt(x + width, y);\n topRightResize.repaint();\n\n bottomRightResize.centerAt(x + width, y + height);\n bottomRightResize.repaint();\n }\n }","@Override\r\n\tpublic void onSizeChanged(int w, int h, int oldW, int oldH) {\r\n\t\t// Set the movement bounds for the ball\r\n\t\txMax = w - 1;\r\n\t\tyMax = h - 1;\r\n\t}","public void mouseDragged(MouseEvent e) {\r\n Graphics g = view.getViewJComponent().getGraphics();\r\n rectangle.setSize(Math.abs(e.getX() - rectangle.x),\r\n Math.abs(e.getY() - rectangle.y));\r\n view.getViewJComponent().repaint();\r\n g.drawRect(rectangle.x, rectangle.y, rectangle.width,\r\n rectangle.height);\r\n }","public void calculateWindow()\n {\n Vector2 windowBottomLeftBounds = new Vector2(1000000, 1000000);\n Vector2 windowTopRightBounds = new Vector2(-1000000, -1000000);\n for (Element e : children())\n {\n if (e.id() != null && (e.id().startsWith(id() + \"hBar\") || e.id().startsWith(id() + \"vBar\")))\n {\n continue;\n }\n for (Element child : e)\n {\n Vector2 alignmentVector = child.alignment().alignmentVector();\n Vector2 bottomLeftBounds = new Vector2(child.x() - (alignmentVector.x * child.width()), child.y()\n - (alignmentVector.y * child.height()));\n Vector2 topRightBounds = new Vector2(bottomLeftBounds.x + child.width(), bottomLeftBounds.y + child.height());\n // left\n if (windowBottomLeftBounds.x > bottomLeftBounds.x)\n {\n windowBottomLeftBounds.x = bottomLeftBounds.x;\n }\n // bottom\n if (windowBottomLeftBounds.y > bottomLeftBounds.y)\n {\n windowBottomLeftBounds.y = bottomLeftBounds.y;\n }\n // right\n if (windowTopRightBounds.x < topRightBounds.x)\n {\n windowTopRightBounds.x = topRightBounds.x;\n }\n // top\n if (windowTopRightBounds.y < topRightBounds.y)\n {\n windowTopRightBounds.y = topRightBounds.y;\n }\n }\n }\n \n content = new CRectangle(windowBottomLeftBounds.x, windowBottomLeftBounds.y, windowTopRightBounds.x - windowBottomLeftBounds.x,\n windowTopRightBounds.y - windowBottomLeftBounds.y);\n content.origin = new Vector2(0, 0);\n \n calculateScrollSize();\n }","@Override\n\tpublic void mouseDragged(MouseEvent e) {\n\t\tif(scale != 1.0) {\n\t\t\tPoint2D.Double view = new Point2D.Double(e.getX(), e.getY());\n\t\t\tPoint2D.Double worldPoint = new Point2D.Double();\n\t\t\tAffineTransform viewToWorld = new AffineTransform(1.0 / scale, 0, 0, 1.0 / scale, worldUpperLeft.getX(), worldUpperLeft.getY());\n\t\t\tviewToWorld.transform(view, worldPoint);\n\t\t\t\n\t\t\twX = worldPoint.getX();\n\t\t\twY = worldPoint.getY();\n\t\n\t\t\tdouble diffX = wDragStartX - wX;\n\t\t\tdouble diffY = wDragStartY - wY;\n\t\t\tdouble wulX = worldUpperLeft.getX();\n\t\t\tdouble wulY = worldUpperLeft.getY();\n\t\t\tdouble newUpX = diffX + wulX;\n\t\t\tdouble newUpY = diffY + wulY;\n\t\t\t\n\t\t\tif(newUpX < 0)\n\t\t\t\tnewUpX = 0;\n\t\t\tif(newUpY < 0)\n\t\t\t\tnewUpY = 0;\n\t\t\tif(scale == 2.0 && newUpX > 512)\n\t\t\t\tnewUpX = 512;\n\t\t\tif(scale == 2.0 && newUpY > 512)\n\t\t\t\tnewUpY = 512;\n\t\t\tif(scale == 4.0 && newUpX > 768)\n\t\t\t\tnewUpX = 768;\n\t\t\tif(scale == 4.0 && newUpY > 768)\n\t\t\t\tnewUpY = 768;\n\t\t\t\n\t\t\tworldUpperLeft = new Point2D.Double(newUpX, newUpY);\n\t\t\t\n\t\t\tif(worldUpperLeft.getX() + scrollbarSize > MAXSCROLLBARSIZE) \n\t\t\t\tGUIFunctions.setHScrollBarPosit(MAXSCROLLBARSIZE - scrollbarSize);\n\t\t\telse \n\t\t\t\tGUIFunctions.setHScrollBarPosit((int) worldUpperLeft.getX());\n\t\t\t\n\t\t\tif(worldUpperLeft.getY() + scrollbarSize > MAXSCROLLBARSIZE) \n\t\t\t\tGUIFunctions.setVScrollBarPosit(MAXSCROLLBARSIZE - scrollbarSize);\n\t\t\telse \n\t\t\t\tGUIFunctions.setVScrollBarPosit((int) worldUpperLeft.getY());\n\t\t\tGUIFunctions.refresh();\n\t\t}\n\t}","private void adjustEViewPosition() {\n double aVec[] = theRocket.getCoordSys().getPositionVec();\n CoordSys eViewSys = new CoordSys();\n eViewSys.setZAxis(VMath.normalize(aVec));\n\n aVec = VMath.vecMultByScalar(aVec, 2.5);\n eViewSys.setPositionAsVec(aVec);\n\n double[] zAxis = VMath.normalize(eViewSys.zAxis().getVectorForm());\n double[] yAxis = VMath.normalize(theRocket.getCoordSys().yAxis().getVectorForm());\n double[] xAxis = VMath.normalize(VMath.crossprd(yAxis, zAxis));\n yAxis = VMath.crossprd(zAxis, xAxis);\n eViewSys.setXAxis(xAxis);\n eViewSys.setYAxis(yAxis);\n eViewSys.setZAxis(zAxis);\n\n eViewSys.xRotate(180);\n eViewSys.zRotate(-90);\n eView.setViewingCoordSys(eViewSys);\n }","@Override\n\tprotected void onSizeChanged(int w, int h, int oldw, int oldh) {\n\t\tsuper.onSizeChanged(w, h, oldw, oldh);\n\t\tif( mr > 0.1f*h ) {\n\t\t\tmr=0.1f*h;\n\t\t\tif( m != null ) {\n\t\t\t\t((CircleObjectKE)m).setR(mr);\n\t\t\t}\n\t\t}\n\t}","public void reshape(GLAutoDrawable drawable, int x, int y, int width, int height) {\n winW = width;\n winH = height;\n\n gl.glViewport(0, 0, width, height);\n}","@Override\n public void setBounds(Rectangle bounds) {\n final Rectangle repaintBounds = new Rectangle(getBounds());\n\n final Rectangle newBounds = new Rectangle(ajustOnGrid(bounds.x),\n ajustOnGrid(bounds.y), ajustOnGrid(bounds.width), bounds.height);\n\n newBounds.width = newBounds.width < MINIMUM_SIZE.x ? MINIMUM_SIZE.x\n : newBounds.width;\n\n this.bounds = newBounds;\n\n parent.getScene().repaint(repaintBounds);\n parent.getScene().repaint(newBounds);\n\n // Move graphics elements associated with this component\n leftMovableSquare.setBounds(computeLocationResizer(0));\n rightMovableSquare.setBounds(computeLocationResizer(bounds.width));\n\n setChanged();\n notifyObservers();\n }","@Override\n public void reshape(GLAutoDrawable drawable, int x, int y, int width, int height) {\n // Get OpenGL context\n gl = drawable.getGL().getGL2();\n\n // Prevent zero height to stop divide by zero errors\n if (height == 0) {\n height = 1;\n }\n float aspect = (float) width / height;\n\n // Set the view port (display area) to cover the entire window\n gl.glViewport(0, 0, width, height);\n\n // Setup perspective projection, with aspect ratio matches viewport\n gl.glMatrixMode(GL_PROJECTION);\n gl.glLoadIdentity();\n glu.gluPerspective(45.0, aspect, 0.1, 100.0);\n\n // Enable the model-view transform\n gl.glMatrixMode(GL_MODELVIEW);\n gl.glLoadIdentity();\n }","public void updateDisplayBounds() {\n if (display_.getDataSource().getBounds() != null) {\n int[] newBounds = display_.getDataSource().getBounds();\n int[] oldBounds = display_.getDisplayModel().getBounds();\n double xResize = (oldBounds[2] - oldBounds[0]) / (double) (newBounds[2] - newBounds[0]);\n double yResize = (oldBounds[3] - oldBounds[1]) / (double) (newBounds[3] - newBounds[1]);\n setImageBounds(newBounds);\n if (xResize < 1 || yResize < 1) {\n zoom(1 / Math.min(xResize, yResize), null);\n }\n }\n }","@Override\n\tpublic void geometry(Geometry geometry) {\n\t\t\n\t}","@As( \"figure with dimensions x: $, y: $, width: $, height: $\" )\n void figure(double x, double y, double width, double height) {\n figure = new SVGRectFigure(x,y,width,height);\n handles.clear();\n ResizeHandleKit.addEdgeResizeHandles(figure,handles);\n ResizeHandleKit.addCornerResizeHandles(figure, handles);\n setUpView();\n }","public abstract Geometry computeGeometry();","@Override\r\n public Dimension getPreferredSize() {\n \r\n return new Dimension((int) (this.getHeight() * 0.8), this.getHeight());\r\n }","@Override\r\n\tprotected void pack() {\r\n\r\n\t\tRectangle displayarea = shell.getDisplay().getPrimaryMonitor().getBounds();\r\n\t\tRectangle windowarea = shell.getBounds();\r\n\t\tshell.setBounds((displayarea.width - windowarea.width) / 2,\r\n\t\t\t\t(displayarea.height - windowarea.height) / 2,\r\n\t\t\t\twindowarea.width, windowarea.height);\r\n\t}","public void setPosicao() {\n Dimension d = this.getDesktopPane().getSize();\n this.setLocation((d.width - this.getSize().width) / 2, (d.height - this.getSize().height) / 2); \n}","@Override\n public void updateCenter(int newX, int newY) {\n Point oldCenter = wrappedPolygon.getCenterPoint();\n wrappedPolygon.translate(newX - oldCenter.x, newY - oldCenter.y);\n }","public Window() {\n // Creation de la fenetre\n super();\n\n // Creation du graphe de scene\n sceneGraph = new SceneGraph(\"Scene Graph\");\n origin = new int[2];\n\n // Proprietes generales de la fenetre\n // Titre de la fenetre\n this.setTitle(NOMFENETRE);\n /// Taille de la fenetre\n this.setSize(HTAILLE, VTAILLE);\n // Centre la fenetre a l'ecran\n this.setLocationRelativeTo(null);\n // Pour fermer la fenetre lorsqu'on clique sur la croix\n this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);\n\n // Creation des composants de la fenetre\n infoBar = new InfoBar();\n treeZone = new TreePanel();\n drawZone = new DrawPanel(infoBar, treeZone);\n optionZone = new OptionPanel(drawZone);\n menuBar = new MenuBar();\n toolBar = new ToolBar(optionZone);\n\n split = new JSplitPane(JSplitPane.HORIZONTAL_SPLIT, treeZone, drawZone);\n split.setDividerLocation(200);\n\n treeZone.initializeListeners(drawZone);\n menuBar.initializeListeners(drawZone);\n\n // Ajout de la barre de menu a la fenetre\n this.setJMenuBar(menuBar);\n // Ajout des differents sous-conteneurs au conteneur principal\n this.getContentPane().setLayout(new BorderLayout());\n this.add(optionZone, BorderLayout.NORTH);\n this.add(toolBar, BorderLayout.WEST);\n this.add(split, BorderLayout.CENTER);\n this.add(infoBar, BorderLayout.SOUTH);\n\n // Affiche la fenetre a l'ecran\n this.setVisible(true);\n\n this.addComponentListener(new ComponentAdapter() {\n\n @Override\n public void componentResized(ComponentEvent e) {\n drawZone.calculateOrigin();\n }\n });\n\n }","public void updateOverviewCanvas() {\n\t\tif (m_mapImage.getImageHeight() == 0 || m_mapImage.getImageWidth() == 0) {\n\t\t\treturn;\n\t\t}\n\t\t\n\t\t// What are the extents of a visible canvas in the ScrollPane/Pane?\n\n\t\t// The bound box changes with dragging\n\t\tBounds b = m_zoomPane.getCanvas().getBoundsInParent();\n\n\t\t// The bound box doesn't change with zoom\n\t\tdouble scale = m_zoomPane.getScale();\n\t\t\n\t\t// System.out.println(b.getMinX() + \" \" + b.getMinY() + \" \" + b.getMaxX() + \" \" + b.getMaxY() + \" \" + scale);\n\t\t\n\t\t// At start, 0.0 and 0.0 is the canvas translation, scale is 1.0\n\t\t// Other bounds describe the overall dimensions.\n\t\t\n\t\t// I need to know the size of the viewport\n\t\t// Then offset that viewport with b.getMinX() and b.getMinY()\n\t\t// And consider the scale factor!\n\t\tBounds sp = scrollPane.getBoundsInLocal();\n\n\t\t// Determine a scale based on what is needed to fit vertically or horizontally into the Canvas.\n\t\tdouble widthRatio = (double) MAX_OVERVIEW_WIDTH / (double) m_mapImage.getImageWidth();\n\t\tdouble heightRatio = (double) MAX_OVERVIEW_HEIGHT / (double) m_mapImage.getImageHeight();\n\t\t\n\t\tdouble scaleFactor = widthRatio < heightRatio ? widthRatio : heightRatio;\n\t\t\n\t\t// Set the transform\n\t\tAffine mat = new Affine(new Scale (scaleFactor, scaleFactor));\n\t\t\n\t\tGraphicsContext gc = m_navigationCanvas.getGraphicsContext2D();\n\t\tgc.clearRect(0, 0, m_navigationCanvas.getWidth(), m_navigationCanvas.getHeight());\n\t\t\n\t\t// Draw image\n\t\tm_mapImage.drawImage(m_navigationCanvas, mat, false);\n\t\t\n\t\t// Draw bounding box\n\t\t// TODO: ugh, this is almost correct but its behaving oddly with the left corner X/Y.\n\t\tdouble dx = (sp.getMaxX() - sp.getMaxX() / scale) / 2;\n\t\tdouble dy = (sp.getMaxY() - sp.getMaxY() / scale) / 2;\n\t\t\n\t\t// double box_xl = - b.getMinX();\n\t\t// double box_yl = - b.getMinY();\n\t\t// double box_xr = - b.getMinX() + sp.getMaxX() / scale;\n\t\t// double box_yr = - b.getMinY() + sp.getMaxY() / scale;\n\t\t\n\t\tdouble box_xl = - b.getMinX() + dx;\n\t\tdouble box_yl = - b.getMinY() + dy;\n\t\tdouble box_xr = - b.getMinX() + sp.getMaxX() / scale + dx;\n\t\tdouble box_yr = - b.getMinY() + sp.getMaxY() / scale + dy;\n\t\t\n\t\t// Clamp to limit the min/max view boxes.\n\t\t//if (box_xl < 0) box_xl = 0;\n\t\t//if (box_yl < 0) box_yl = 0;\n\t\t//if (box_xr > m_navigationCanvas.getWidth()) box_xr = m_navigationCanvas.getWidth();\n\t\t//if (box_yr > m_navigationCanvas.getHeight()) box_yr = m_navigationCanvas.getHeight();\n\t\t\n\t\t// Let's describe how the viewport would be in the canvas.\n\t\tVector3 pt1 = m_zoomPane.getActualPixelPosition(box_xl, box_yl);\n\t\tVector3 pt2 = m_zoomPane.getActualPixelPosition(box_xl, box_yr);\n\t\tVector3 pt3 = m_zoomPane.getActualPixelPosition(box_xr, box_yr);\n\t\tVector3 pt4 = m_zoomPane.getActualPixelPosition(box_xr, box_yl);\n\t\t\n\t\t// Save the transform state\n\t\tgc.save();\n gc.setTransform(mat);\n \n\t\tColor c = Color.RED;\n // Draw some lines.\n\t\tgc.beginPath();\n\t\tgc.setStroke(c);\n\t\tgc.setFill(c);\n\t\tgc.setLineWidth(1.0 / scaleFactor);\n\t\t\n gc.moveTo(pt1.x, pt1.y);\n gc.lineTo(pt2.x, pt2.y);\n gc.moveTo(pt2.x, pt2.y);\n gc.lineTo(pt3.x, pt3.y);\n \n gc.moveTo(pt3.x, pt3.y);\n gc.lineTo(pt4.x, pt4.y);\n gc.moveTo(pt4.x, pt4.y);\n gc.lineTo(pt1.x, pt1.y);\n \n gc.stroke();\n gc.closePath();\n \n gc.restore();\n\t}","@Override\r\npublic void componentResized(ComponentEvent arg0) {\n\tsetSizeBackgr(getSize());\r\n\tsetSizeHat (getSize());\r\n\tsetSizeGift(getSize());\r\n}","private void applyWindowToViewportTransformation(Graphics2D g2,\n double left, double right, double bottom, double top,\n boolean preserveAspect) {\n int width = getWidth();\n int height = getHeight();\n if (preserveAspect) {\n double displayAspect = Math.abs((double) height / width);\n double requestedAspect = Math.abs((bottom - top) / (right - left));\n if (displayAspect > requestedAspect) {\n double excess = (bottom - top) * (displayAspect / requestedAspect - 1);\n bottom += excess / 2;\n top -= excess / 2;\n } else if (displayAspect < requestedAspect) {\n double excess = (right - left) * (requestedAspect / displayAspect - 1);\n right += excess / 2;\n left -= excess / 2;\n }\n }\n g2.scale(width / (right - left), height / (bottom - top));\n g2.translate(-left, -top);\n double pixelWidth = Math.abs((right - left) / width);\n double pixelHeight = Math.abs((bottom - top) / height);\n pixelSize = (float) Math.max(pixelWidth, pixelHeight);\n }","private void sendResizeEventToFX() {\n redraw();\n update();\n \n pWidth = getClientArea().width;\n pHeight = getClientArea().height;\n\n resizePixelBuffer(lastScaleFactor);\n\n if (scenePeer == null) {\n return;\n }\n\n stagePeer.setSize(pWidth, pHeight);\n scenePeer.setSize(pWidth, pHeight);\n }","@objid (\"1b87bc2e-5e33-11e2-b81d-002564c97630\")\n private Point getViewAreaSize() {\n final Point controlSize = new Point(0, 0);\n // this has to be done in the display thread to avoid\n // InvalidThreadAccessException.\n getViewer().getControl().getDisplay().syncExec(new Runnable() {\n @Override\n public void run() {\n final Control control = BackgroundEditPart.this.getViewer().getControl();\n Point p = control.getSize();\n controlSize.x = p.x;\n controlSize.y = p.y;\n \n if (control instanceof Scrollable) {\n Scrollable c = (Scrollable) control;\n ScrollBar b = c.getHorizontalBar();\n if (b != null /* && b.isVisible() */) {\n controlSize.y -= b.getSize().y;\n }\n b = c.getVerticalBar();\n if (b != null /* && b.isVisible() */) {\n controlSize.x -= b.getSize().x;\n }\n }\n }\n });\n return controlSize;\n }","public void updateBoundaries() {\n\t\t\n\t\tLOG.log(\"Updating boundaries.\");\n\t\t\n\t\tif (Program.WINDOW_MANAGER != null) {\n\t\t\t\n\t\t\tthis.setBounds(\n\t\t\t\tProgram.WINDOW_MANAGER.getScreenWidth() / 2 - this.getSize().width / 2,\n\t\t\t\tProgram.WINDOW_MANAGER.getScreenHeight() / 2 - this.getSize().height / 2,\n\t\t\t\tBOUNDS_LENGTH,\n\t\t\t\tBOUNDS_WIDTH\n\t\t\t);\n\t\t\tthis.setLocationRelativeTo(null);\n\t\t\t\n\t\t} else {\n\t\t\tthis.setBounds(10, 10, BOUNDS_LENGTH, BOUNDS_WIDTH);\n\t\t}\n\t}","private void transformObject(int x, int y) {\n double sx, sy, l, r, nx, ny, tx, ty, alpha, origCX = 0, origCY = 0;\n Rectangle bnds;\n\n if(curr_obj == transformPointers[Action.ROTATE]) {\n /* the mouse vector 1 */\n GeoVector mouseVector = new GeoVector(x, y, this.aux_obj.getCenterX(), this.aux_obj.getCenterY());\n\n /* the rotation vector. i.e. the fixed vector that will be used as origin composed by the subtraction of the object center with the rotation point */\n GeoVector rotationVector = new GeoVector(this.lastPosition[0], this.lastPosition[1], this.aux_obj.getCenterX(), this.aux_obj.getCenterY());\n\n mouseVector.normalize();\n rotationVector.normalize();\n\n alpha = mouseVector.getAngleWith(rotationVector.getX(), rotationVector.getY());\n\n /** After passing the 180 degrees, the atan2 function returns a negative angle from 0 to PI. So this will convert the final gobal angle to 0-2PI */\n if(alpha < 0 ) {\n alpha = (2 * Math.PI) + alpha; \n }\n\n alpha -= this.currRotation;\n this.currRotation += alpha;\n\n Point c = new Point(this.aux_obj.getCenterX(), this.aux_obj.getCenterY());\n this.aux_obj.uRotate((float)(-1.0*(alpha*(180/Math.PI))), c);\n \n } else {\n alpha = this.aux_obj.getRotation();\n\n /** Here we rotate the selected Graphic Object, it's tranformation points and the mouse coordinates back to the zero angle, to permit a correct object scalling. */\n if(alpha != 0.0) {\n origCX = this.aux_obj.getCenterX();\n origCY = this.aux_obj.getCenterY();\n this.aux_obj.uRotate((float)(alpha*-1.0), this.aux_obj.getCenter());\n rotateTransformPoints(alpha);\n GeoVector mouseCoord = new GeoVector(x, y, this.aux_obj.getCenterX(), this.aux_obj.getCenterY());\n\n mouseCoord.rotate( ((alpha*-1.0) * (2.0*Math.PI))/360 );\n mouseCoord.addPoint(this.aux_obj.getCenterX(), this.aux_obj.getCenterY());\n x = (int)mouseCoord.getX();\n y = (int)mouseCoord.getY();\n\n }\n\n /** Tatami rotates the object from it's x and y point to the edges. So this means that sometimes we need to translate the object a few pixels to asure that it's upper left corner is on the same position. */\n if(curr_obj == transformPointers[Action.NORTHWEST]) {\n if(x < (transformPointers[Action.EAST].getX()-2) && y < (transformPointers[Action.SOUTH].getY()-2)) {\n l = aux_obj.getX() - (transformPointers[Action.WEST].getX()+2);\n r = (transformPointers[Action.EAST].getX()+2) - aux_obj.getX();\n nx = (transformPointers[Action.EAST].getX()+2) - x ;\n sx = nx / (l+r);\n tx = (sx*l-l) + (sx*r-r);\n\n l = aux_obj.getY() - (transformPointers[Action.NORTH].getY()+2);\n r = (transformPointers[Action.SOUTH].getY()+2) - aux_obj.getY();\n ny = (transformPointers[Action.SOUTH].getY()+2) - y;\n sy = ny / (l+r);\n ty = (sy*l-l) + (sy*r-r);\n\n aux_obj.uTranslate((int)-tx, (int)-ty);\n aux_obj.scale( (float)sx, (float)sy);\n\n if(alpha != 0.0) {\n this.aux_obj.uTranslate((int)(origCX - this.aux_obj.getCenterX()), (int)(origCY - this.aux_obj.getCenterY()));\n this.aux_obj.rotate((float)alpha);\n }\n\n canvas.remove(transformPoints);\n transformPoints.clear();\n bnds = aux_obj.getBounds();\n createTransformPoints(bnds, aux_obj);\n curr_obj = transformPointers[Action.NORTHWEST];\n }\n } else if(curr_obj == transformPointers[Action.NORTH]) {\n if(y < (transformPointers[Action.SOUTH].getY()-2)) {\n l = aux_obj.getY() - (transformPointers[Action.NORTH].getY()+2);\n r = (transformPointers[Action.SOUTH].getY()+2) - aux_obj.getY();\n ny = (transformPointers[Action.SOUTH].getY()+2) - y;\n sy = ny / (l+r);\n ty = (sy*l-l) + (sy*r-r);\n\n aux_obj.uTranslate(0, (int)-ty);\n aux_obj.scale( 1, (float)sy);\n\n if(alpha != 0.0) {\n this.aux_obj.uTranslate((int)(origCX - this.aux_obj.getCenterX()), (int)(origCY - this.aux_obj.getCenterY()));\n this.aux_obj.rotate((float)alpha);\n }\n\n canvas.remove(transformPoints);\n transformPoints.clear();\n bnds = aux_obj.getBounds();\n createTransformPoints(bnds, aux_obj);\n curr_obj = transformPointers[Action.NORTH];\n }\n } else if(curr_obj == transformPointers[Action.NORTHEAST]) {\n if(x > (transformPointers[Action.WEST].getX()+2) && y < (transformPointers[Action.SOUTH].getY()-2)) {\n l = aux_obj.getX() - (transformPointers[Action.WEST].getX()+2);\n r = (transformPointers[Action.EAST].getX()+2) - aux_obj.getX();\n nx = x - (transformPointers[Action.WEST].getX()+2);\n sx = nx / (l+r);\n tx = sx*l-l;\n\n l = aux_obj.getY() - (transformPointers[Action.NORTH].getY()+2);\n r = (transformPointers[Action.SOUTH].getY()+2) - aux_obj.getY();\n ny = (transformPointers[Action.SOUTH].getY()+2) - y;\n sy = ny / (l+r);\n ty = (sy*l-l) + (sy*r-r);\n\n aux_obj.uTranslate((int)tx, (int)-ty);\n aux_obj.scale( (float)sx, (float)sy);\n\n if(alpha != 0.0) {\n this.aux_obj.uTranslate((int)(origCX - this.aux_obj.getCenterX()), (int)(origCY - this.aux_obj.getCenterY()));\n this.aux_obj.rotate((float)alpha);\n }\n\n canvas.remove(transformPoints);\n transformPoints.clear();\n bnds = aux_obj.getBounds();\n createTransformPoints(bnds, aux_obj);\n curr_obj = transformPointers[Action.NORTHEAST];\n }\n\n } else if(curr_obj == transformPointers[Action.WEST]) {\n if(x < (transformPointers[Action.EAST].getX()-2) ) {\n l = aux_obj.getX() - (transformPointers[Action.WEST].getX()+2);\n r = (transformPointers[Action.EAST].getX()+2) - aux_obj.getX();\n nx = (transformPointers[Action.EAST].getX()+2) - x ;\n sx = nx / (l+r);\n tx = (sx*l-l) + (sx*r-r);\n\n aux_obj.uTranslate((int)-tx, 0);\n aux_obj.scale( (float)sx, 1);\n\n if(alpha != 0.0) {\n this.aux_obj.uTranslate((int)(origCX - this.aux_obj.getCenterX()), (int)(origCY - this.aux_obj.getCenterY()));\n this.aux_obj.rotate((float)alpha);\n }\n\n canvas.remove(transformPoints);\n transformPoints.clear();\n\n bnds = aux_obj.getBounds();\n createTransformPoints(bnds, aux_obj);\n curr_obj = transformPointers[Action.WEST];\n }\n } else if(curr_obj == transformPointers[Action.EAST]) {\n if(x > (transformPointers[Action.WEST].getX()+2) ) {\n l = aux_obj.getX() - (transformPointers[Action.WEST].getX()+2);\n r = (transformPointers[Action.EAST].getX()+2) - aux_obj.getX();\n nx = x - (transformPointers[Action.WEST].getX()+2);\n sx = nx / (l+r);\n tx = sx*l-l;\n\n aux_obj.uTranslate((int)tx, 0);\n aux_obj.scale( (float)sx, (float)1);\n\n if(alpha != 0.0) {\n this.aux_obj.uTranslate((int)(origCX - this.aux_obj.getCenterX()), (int)(origCY - this.aux_obj.getCenterY()));\n this.aux_obj.rotate((float)alpha);\n }\n\n canvas.remove(transformPoints);\n transformPoints.clear();\n bnds = aux_obj.getBounds();\n createTransformPoints(bnds, aux_obj);\n curr_obj = transformPointers[Action.EAST];\n }\n } else if(curr_obj == transformPointers[Action.SOUTHWEST]) {\n if(x < (transformPointers[Action.EAST].getX()-2) && y > (transformPointers[Action.NORTH].getY()+2)) {\n l = aux_obj.getX() - (transformPointers[Action.WEST].getX()+2);\n r = (transformPointers[Action.EAST].getX()+2) - aux_obj.getX();\n nx = (transformPointers[Action.EAST].getX()+2) - x ;\n sx = nx / (l+r);\n tx = (sx*l-l) + (sx*r-r);\n\n l = aux_obj.getY() - (transformPointers[Action.NORTH].getY()+2);\n r = (transformPointers[Action.SOUTH].getY()+2) - aux_obj.getY();\n ny = y - (transformPointers[Action.NORTH].getY()+2);\n sy = ny / (l+r);\n ty = sy*l-l;\n\n aux_obj.uTranslate((int)-tx, (int)ty);\n aux_obj.scale( (float)sx, (float)sy);\n\n if(alpha != 0.0) {\n this.aux_obj.uTranslate((int)(origCX - this.aux_obj.getCenterX()), (int)(origCY - this.aux_obj.getCenterY()));\n this.aux_obj.rotate((float)alpha);\n }\n\n canvas.remove(transformPoints);\n transformPoints.clear();\n bnds = aux_obj.getBounds();\n createTransformPoints(bnds, aux_obj);\n curr_obj = transformPointers[Action.SOUTHWEST];\n }\n } else if(curr_obj == transformPointers[Action.SOUTH]) {\n if(y > (transformPointers[Action.NORTH].getY()+2)) {\n l = aux_obj.getY() - (transformPointers[Action.NORTH].getY()+2);\n r = (transformPointers[Action.SOUTH].getY()+2) - aux_obj.getY();\n ny = y - (transformPointers[Action.NORTH].getY()+2);\n sy = ny / (l+r);\n ty = sy*l-l;\n\n aux_obj.uTranslate(0, (int)ty);\n aux_obj.scale( 1, (float)sy);\n\n if(alpha != 0.0) {\n this.aux_obj.uTranslate((int)(origCX - this.aux_obj.getCenterX()), (int)(origCY - this.aux_obj.getCenterY()));\n this.aux_obj.rotate((float)alpha);\n }\n\n canvas.remove(transformPoints);\n transformPoints.clear();\n bnds = aux_obj.getBounds();\n createTransformPoints(bnds, aux_obj);\n curr_obj = transformPointers[Action.SOUTH];\n }\n } else if(curr_obj == transformPointers[Action.SOUTHEAST]) {\n if(x > (transformPointers[Action.WEST].getX()+2) && y > (transformPointers[Action.NORTH].getY()+2)) {\n\n l = aux_obj.getX() - (transformPointers[Action.WEST].getX()+2);\n r = (transformPointers[Action.EAST].getX()+2) - aux_obj.getX();\n nx = x - (transformPointers[Action.WEST].getX()+2);\n sx = nx / (l+r);\n tx = sx*l-l;\n\n l = aux_obj.getY() - (transformPointers[Action.NORTH].getY()+2);\n r = (transformPointers[Action.SOUTH].getY()+2) - aux_obj.getY();\n ny = y - (transformPointers[Action.NORTH].getY()+2);\n sy = ny / (l+r);\n ty = sy*l-l;\n\n aux_obj.uTranslate((int)tx, (int)ty);\n aux_obj.scale( (float)sx, (float)sy);\n\n if(alpha != 0.0) {\n this.aux_obj.uTranslate((int)(origCX - this.aux_obj.getCenterX()), (int)(origCY - this.aux_obj.getCenterY()));\n this.aux_obj.rotate((float)alpha);\n }\n\n canvas.remove(transformPoints);\n transformPoints.clear();\n bnds = aux_obj.getBounds();\n createTransformPoints(bnds, aux_obj);\n curr_obj = transformPointers[Action.SOUTHEAST];\n }\n }\n\n\n }\n \n }","private void updateBoundingBox()\n\t{\n\t\tif (this.facingDirection != null)\n\t\t{\n\t\t\tdouble d0 = (double) this.hangingPosition.getX() + 0.5D;\n\t\t\tdouble d1 = (double) this.hangingPosition.getY() + 0.5D;\n\t\t\tdouble d2 = (double) this.hangingPosition.getZ() + 0.5D;\n\t\t\tdouble d3 = 0.46875D;\n\t\t\tdouble d4 = this.someFunc(this.getWidthPixels());\n\t\t\tdouble d5 = this.someFunc(this.getHeightPixels());\n\t\t\td0 = d0 - (double) this.facingDirection.getFrontOffsetX() * 0.46875D;\n\t\t\td2 = d2 - (double) this.facingDirection.getFrontOffsetZ() * 0.46875D;\n\t\t\td1 = d1 + d5;\n\t\t\tEnumFacing enumfacing = this.facingDirection.rotateYCCW();\n\t\t\td0 = d0 + d4 * (double) enumfacing.getFrontOffsetX();\n\t\t\td2 = d2 + d4 * (double) enumfacing.getFrontOffsetZ();\n\t\t\tthis.posX = d0;\n\t\t\tthis.posY = d1;\n\t\t\tthis.posZ = d2;\n\t\t\tdouble d6 = (double) this.getWidthPixels();\n\t\t\tdouble d7 = (double) this.getHeightPixels();\n\t\t\tdouble d8 = (double) this.getWidthPixels();\n\n\t\t\tif (this.facingDirection.getAxis() == EnumFacing.Axis.Z)\n\t\t\t{\n\t\t\t\td8 = 1.0D;\n\t\t\t}\n\t\t\telse\n\t\t\t{\n\t\t\t\td6 = 1.0D;\n\t\t\t}\n\n\t\t\t// ???\n\n\t\t\td6 = d6 / (this.getWidthPixels() / this.blocksToTakeUp() * 2D);\n\t\t\td7 = d7 / (this.getHeightPixels() / this.blocksToTakeUp() * 2D);\n\t\t\td8 = d8 / (this.getWidthPixels() / this.blocksToTakeUp() * 2D);\n\t\t\tthis.setEntityBoundingBox(new AxisAlignedBB(d0 - d6, d1 - d7, d2 - d8, d0 + d6, d1 + d7, d2 + d8));\n\t\t}\n\t}","public void centreModel(){\n\t\tcentreModel(modOffset);\n\t}","public void normalizeCoordinates2D(Agent agent)\n {\n if (agent.x() < 0.5)\n {\n agent.getKinematic().setX(this.getWidth() - 0.5);\n }\n else if (agent.x() > this.getWidth() - 0.5)\n {\n agent.getKinematic().setX(0.5);\n }\n\n if (agent.y() < 0.5)\n {\n agent.getKinematic().setY(this.getHeight() - 0.5);\n }\n else if (agent.y() > this.getHeight() - 0.5)\n {\n agent.getKinematic().setY(0.5);\n }\n }","public void resize() {\n\t\tsp.doLayout();\n\t}","private void updateDimensions() {\r\n width = gui.getWidth();\r\n height = gui.getHeight();\r\n yLabelsMargin = (int) gui.getLabelWidth(Integer.toString(((int) maximumDB / 10) * 10), true) + 2;\r\n if (track != null)\r\n scaleXpx = ((float) width - yLabelsMargin) / track.getBufferCapacity();\r\n else\r\n scaleXpx = 1;\r\n scaleYpx = (float) ((height - 1) / (maximumDB - minimumDB));\r\n if (scaleYpx == 0)\r\n scaleYpx = 1;\r\n }","private void geometry()\n\t\t{\n\t\tgridLayout = new GridLayout(2, -1);\n\n\t\tthis.setLayout(gridLayout);\n\n\t\tadd(component1);\n\t\tadd(component2);\n\t\t}","public void onUpdate()\n\t{\n\t\tchunk.setModelBound(new BoundingBox());\n\t\tchunk.updateModelBound();\n\n\t}","@Override\r\n public void reshape(GLAutoDrawable drawable, int x, int y, int width, int height) {\n GL2 gl = drawable.getGL().getGL2();\r\n\r\n //evita a divisão por zero\r\n if (height == 0) {\r\n height = 1;\r\n }\r\n //calcula a proporção da janela (aspect ratio) da nova janela\r\n float aspect = (float) width / height;\r\n\r\n //seta o viewport para abranger a janela inteira\r\n gl.glViewport(0, 0, width, height);\r\n\r\n //ativa a matriz de projeção\r\n gl.glMatrixMode(GL2.GL_PROJECTION);\r\n gl.glLoadIdentity(); //lê a matriz identidade\r\n\r\n //Projeção ortogonal\r\n //true: aspect >= 1 configura a altura de -1 para 1 : com largura maior\r\n //false: aspect < 1 configura a largura de -1 para 1 : com altura maior\r\n if (width >= height) {\r\n gl.glOrtho(xMin * aspect, xMax * aspect, yMin, yMax, zMin, zMax);\r\n } else {\r\n gl.glOrtho(xMin, xMax, yMin / aspect, yMax / aspect, zMin, zMax);\r\n }\r\n\r\n //ativa a matriz de modelagem\r\n gl.glMatrixMode(GL2.GL_MODELVIEW);\r\n gl.glLoadIdentity(); //lê a matriz identidade\r\n System.out.println(\"Reshape: \" + width + \", \" + height);\r\n }","public void setMovingBounds() {\r\n maxY = this.getParent().getYmax();\r\n minY = this.getParent().getYmin();\r\n maxX = this.getParent().getXmax();\r\n minX = this.getParent().getXmin();\r\n }","public void adjustSize() {\r\n /*\r\n * Calculate target width: max of header, adjusted window, content\r\n * \r\n * TODO: restrict to available desktop space\r\n */\r\n int targetWidth = TOTAL_BORDER_THICKNESS\r\n + MathUtils.maxInt(headerBar.getOffsetWidth(),\r\n contentWidget.getOffsetWidth(), getWidth()\r\n - TOTAL_BORDER_THICKNESS);\r\n /*\r\n * Calculate target height: max of adjusted window, content\r\n * \r\n * TODO: restrict to available desktop space\r\n */\r\n int targetHeight = TOTAL_BORDER_THICKNESS\r\n + MathUtils.maxInt(contentWidget.getOffsetHeight(), getHeight()\r\n - TOTAL_BORDER_THICKNESS - headerBar.getOffsetHeight());\r\n\r\n setPixelSize(targetWidth, targetHeight);\r\n }","public abstract Transformation updateTransform(Rectangle selectionBox);","public void onSizeChanged(int w, int h, int oldw, int oldh) {\r\n super.onSizeChanged(w, h, oldw, oldh);\r\n returnDefualt();\r\n this.startWidth = (float)getWidth()/4;\r\n this.endWidth = (float)getWidth()-((float)getWidth()/4);\r\n this.startHeight = (float)getHeight()/12;\r\n this.endHeight = getHeight()-((float)getHeight()/12);\r\n this.oval = new RectF(this.startWidth,this.startHeight , this.endWidth, this.endHeight);\r\n }","@Override\n protected void buildWorldRepresentation() {\n java.util.List worldModelEntityList = spaceExplorerModel.getWorldEntityList();\n java.util.List viewWorldEntityList = new ArrayList();\n for (int i = 0; i < worldModelEntityList.size(); i++) {\n\n BasicModelEntity basicModelEntity = worldModelEntityList.get(i);\n\n CSysEntity cSysEntity = null;\n if (basicModelEntity instanceof ModelLineEntity) {\n cSysEntity = new SeCSysLineEntity(this, (ModelLineEntity) basicModelEntity);\n cSysEntity.setDrawColor(basicModelEntity.getColor());\n// addWorldEntity(cSysLineEntity);\n } else if (basicModelEntity instanceof ModelPolyLineEntity) {\n cSysEntity = new SeCSysViewPolyLineEntity(this, (ModelPolyLineEntity) basicModelEntity);\n cSysEntity.setDrawColor(basicModelEntity.getColor());\n// addWorldEntity(seCSysViewPolylineEntity);\n }\n viewWorldEntityList.add(cSysEntity);\n }\n\n createAxis(viewWorldEntityList);\n viewWorldEntityArray = viewWorldEntityList.toArray(new BasicCSysEntity[viewWorldEntityList.size()]);\n updateCSysEntList(combinedRotatingMatrix);\n }","private void centre() {\n Dimension localDimension = Toolkit.getDefaultToolkit().getScreenSize();\n int i2 = (int) Math.min(localDimension.width * WIDTH, localDimension.height * WIDTH);\n\n Rectangle localRectangle = new Rectangle();\n localRectangle.setBounds(((localDimension.width - i2) / TWO), \n ((localDimension.height - i2) / TWO), i2, i2);\n\n setBounds(localRectangle);\n\n }","void resetRoundHitbox() {\n setRoundHitbox((_w+_h)/4);\n }","@Override\n public void resize()\n {\n if (this.resizer != null)\n {\n this.resizer.apply(this.area);\n }\n\n if (this.children != null)\n {\n this.children.resize();\n }\n\n if (this.resizer != null)\n {\n this.resizer.postApply(this.area);\n }\n }","public void updateBounds() {\n\t\tswitch (this.species){\n\t\tcase HOGCHOKER:\n\t\tcase SILVERSIDE:\n\t\tcase FLOUNDER:\n\t\t\tthis.topYBound = frameHeight / 3 * 2;\n\t\t\tthis.bottomYBound = frameHeight - imageHeight - frameBarSize;\n\t\t\tbreak;\n\t\tcase PERCH: \n\t\tcase MINNOW: \n\t\tcase WEAKFISH:\n\t\t\tthis.topYBound = frameHeight / 3;\n\t\t\tthis.bottomYBound = frameHeight / 3 * 2 - imageHeight;\n\t\t\tbreak;\n\n\t\tcase MENHADEN:\n\t\tcase MUMMICHOG:\n\t\t\tthis.topYBound = 0;\n\t\t\tthis.bottomYBound = frameHeight / 3 - imageHeight;\n\t\t\tbreak;\n\t\tcase GOLD:\n\t\tdefault:\n\t\t\ttopYBound = 0;\n\t\t\tbottomYBound = frameHeight;\n\t\t}\n\t}","@Override\n\tpublic BoundaryRectangle getBoundingBox() {\n\t\treturn new BoundaryRectangle(0, 0, drawView.getWidth(), drawView.getHeight());\n\t}","private void setDimensions() {\n IPhysicalVolume physVol_parent = getModule().getGeometry().getPhysicalVolume();\n ILogicalVolume logVol_parent = physVol_parent.getLogicalVolume();\n ISolid solid_parent = logVol_parent.getSolid();\n Box box_parent;\n if (Box.class.isInstance(solid_parent)) {\n box_parent = (Box) solid_parent;\n } else {\n throw new RuntimeException(\"Couldn't cast the module volume to a box!?\");\n }\n _length = box_parent.getXHalfLength() * 2.0;\n _width = box_parent.getYHalfLength() * 2.0;\n\n }","private void setGeometry() {\n this.setCullHint(Spatial.CullHint.Dynamic);\n this.setLocalTranslation(realPosition);\n //attach geometry to this object\n // mat.setColor(\"Color\", colors[r.nextInt(colors.length)]);\n if (!companyTextures.containsKey(this.company)) {\n mat.setTexture(\"ColorMap\", Colors.get(r.nextInt(Colors.size())));\n } else {\n mat.setTexture(\"ColorMap\", companyTextures.get(this.company));\n }\n geom.setMaterial(mat);\n this.attachChild(geom.clone());\n }","protected Rectangle determineBounds() {\n return getNetTransform().createTransformedShape( _bounds ).getBounds();\n }","public Rectangle getPlotBounds();","@Override\n\tpublic void renderGeometry(SvgRenderContext state) {\n\t\t\n\t}","public void componentResized(ComponentEvent event) {\n // first, size the lights and corners\n double width = (double)getWidth() / ((double)maxHorizontalLights + 2); //< +2 for the corners!\n double height = (double)getHeight() / ((double)maxVerticalLights + 2); //< +2 for the corners!\n Dimension lightDimension = new Dimension((int)Math.round(width), (int)Math.round(height));\n \n // now set the locations and sizes of each light\n // top border location\n double x = width;\n double y = 0;\n for (int i = 0; i < topBorder.size(); i++) {\n topBorder.get(i).setPosition(x, y);\n topBorder.get(i).setPreferredSize(lightDimension);\n topBorder.get(i).setSize(lightDimension);\n x += width;\n }\n \n // bottom border locations\n x = width;\n y = getHeight() - height;\n for (int i = 0; i < bottomBorder.size(); i++) {\n bottomBorder.get(i).setPosition(x, y);\n bottomBorder.get(i).setPreferredSize(lightDimension);\n bottomBorder.get(i).setSize(lightDimension);\n x += width;\n }\n bottomRight.setPosition(x, y);\n \n // left border locations\n x = 0;\n y = height;\n for (int i = 0; i < leftBorder.size(); i++) {\n leftBorder.get(i).setPosition(x, y);\n leftBorder.get(i).setPreferredSize(lightDimension);\n leftBorder.get(i).setSize(lightDimension);\n y += height;\n }\n \n // right border\n x = getWidth() - width;\n y = height;\n for (int i = 0; i < rightBorder.size(); i++) {\n rightBorder.get(i).setPosition(x, y);\n rightBorder.get(i).setPreferredSize(lightDimension);\n rightBorder.get(i).setSize(lightDimension);\n y += height;\n }\n \n // set the size and locations of the corners\n x = 0;\n y = 0;\n topLeft.setPosition(x, y);\n topLeft.setPreferredSize(lightDimension);\n topLeft.setSize(lightDimension);\n x = getWidth() - width;\n y = 0;\n topRight.setPosition(x, y);\n topRight.setPreferredSize(lightDimension);\n topRight.setSize(lightDimension);\n x = 0;\n y = getHeight() - height;\n bottomLeft.setPosition(x, y);\n bottomLeft.setPreferredSize(lightDimension);\n bottomLeft.setSize(lightDimension);\n x = getWidth() - width;\n y = getHeight() - height;\n bottomRight.setPosition(x, y);\n bottomRight.setPreferredSize(lightDimension);\n bottomRight.setSize(lightDimension);\n \n // set the location and size of the tumbler display\n width = getWidth() - (2 * width);\n height = getHeight() - (2 * height);\n Dimension tumblerDisplayDimension = new Dimension((int)Math.round(width), (int)Math.round(height));\n tumblerDisplay.setPreferredSize(tumblerDisplayDimension);\n tumblerDisplay.setSize(tumblerDisplayDimension);\n tumblerDisplay.setLocation(topLeft.getWidth(), topLeft.getHeight());\n }","protected void layoutImpl()\n {\n // Set chart area height first, since height can effect yaxis label width\n double pw = getWidth(), ph = getHeight();\n double ah = _xaxis.isVisible()? _xaxis.getPrefHeight() : 0;\n _chartArea.setHeight(ph - ah);\n \n // Now set bounds of areay, xaxis and yaxis\n double aw = _yaxis.isVisible()? _yaxis.getPrefWidth(ph - ah) : 0;\n double cw = pw - aw, ch = ph - ah;\n _chartArea.setBounds(aw,0,cw,ch);\n _xaxis.setBounds(aw,ch,cw,ah);\n _yaxis.setBounds(0,0,aw,ch);\n }","private void destroyBounds() {\n size -= 4;\n this.setBounds(bounds.left, bounds.top);\n if (size <= 0) models.remove(this);\n }","@Override\n public void onSizeChanged(int w, int h, int oldW, int oldH) {\n // Set the movement bounds for the ball\n displayArea.setDisp(w-1, h-1);\n if (!isInitBackground) {\n isInitBackground = true;\n backgCalculating = new BackCalculating(0, 0, displayArea.xMax, displayArea.yMax, Color.BLACK, Color.YELLOW);\n }\n }","@Override\n public void componentResized(ComponentEvent arg0) {\n width = jframe.getSize().getWidth();\n height = jframe.getSize().getHeight();\n baseBallCard.setLocation(0, (int) height - 175);\n gearbutton.setLocation((int) width - 79, (int) height - 99);\n settingspanel.setSize(new Dimension((int) (.6 * width), (int) (.6 * height)));\n settingspanel.setLocation((int) (.2 * width), (int) (.15 * height));\n int sx = (int) (.6 * width);\n int sy = (int) (.6 * height);\n storyPanel.setSize(new Dimension((int) (.6 * width), (int) (.6 * height)));\n storyPanel.setLocation((int) (.2 * width), (int) (.15 * height));\n storyPanel.setBackground(new Color(.8f, .8f, 1f, .75f));\n story.setSize(new Dimension(storyPanel.getWidth()-50, storyPanel.getHeight()-50));\n story.setBackground(new Color(.8f, .8f, 1f, .75f));\n story.setLocation(25,25);\n sphereSize.setSize((int) (.3 * sx), 20);\n bgColor.setSize((int) (.3 * sx), 20);\n sphereSize.setLocation((int) (.1 * sx), (int) (.25 * sy));\n bgColor.setLocation((int) (.1 * sx), (int) (.35 * sy));\n bgtext.setLocation((int) (.5 * sx), (int) (.35 * sy));\n sphsi.setLocation((int) (.5 * sx), (int) (.25 * sy));\n showall.setLocation((int) (.5 * sx), (int) (.8 * sy));\n points.setLocation((int) (.175 * sx), (int) (.7 * sy));\n debug.setLocation((int) (.175 * sx), (int) (.8 * sy));\n wireframe.setLocation((int) (.175 * sx), (int) (.9 * sy));\n close.setLocation(sx - 30, sy - (sy - 10));\n aboutpanel.setSize(new Dimension(461, 347));\n aboutpanel.setLocation((int) (.3 * width), (int) (.3 * height));\n aboutpanel.add(aboutclose);\n aboutclose.setLocation(440, 10);\n resetrestrictions.setLocation((int) (.025 * sx), 25);\n glcanvas.requestFocusInWindow();\n }","@Override\r\n\t\tpublic void update(Rectangle2D r) {\r\n\t\t\t\r\n\t\t\tmakeDirty(r, false);\r\n\t\t\tif (_clipping != null) \r\n\t\t\t\trepaint(_clipping.getTransform().createTransformedShape(r).getBounds());\r\n\t\t}","public RMRect getFrame() { return isRSS()? convertRectToShape(getBoundsInside(), _parent) : getBounds(); }","private void expandDirtyRect(float historicalX, float historicalY) {\n if (historicalX < mDirtyRect.left) {\n mDirtyRect.left = historicalX;\n } else if (historicalX > mDirtyRect.right) {\n mDirtyRect.right = historicalX;\n }\n if (historicalY < mDirtyRect.top) {\n mDirtyRect.top = historicalY;\n } else if (historicalY > mDirtyRect.bottom) {\n mDirtyRect.bottom = historicalY;\n }\n }","public void computeSRectangleBound()\n {\n this.savedSRectangleBound = getSRectangleBound();\n }","private void updateBoundary() {\n //pos = _newPos ;\n heading = myRoute.getCurrentHeading() ;\n //System.out.println(\"heading=\"+heading);\n Point vertex = new Point(0,0) ;\n vertex.x = length/2 ;\n vertex.y = width/2 ;\n boundary[0] = transform(vertex) ;\n \n vertex.x = -length/2 ;\n vertex.y = width/2 ;\n boundary[1] = transform(vertex) ;\n \n vertex.x = -length/2 ;\n vertex.y = -width/2 ;\n boundary[2] = transform(vertex) ;\n \n vertex.x = length/2 ;\n vertex.y = -width/2 ;\n boundary[3] = transform(vertex) ;\n for (int i=0; i<4; i++) {\n xpoints[i] = boundary[i].x ;\n ypoints[i] = boundary[i].y ;\n }\n }","private void recalculatePosition()\n {\n position.x = gridCoordinate.getCol()*(width+horizontal_spacing);\n position.y = gridCoordinate.getRow()*(heigh+vertical_spacing);\n }","public void setGraphicalWidgetBounds(double tempOriginX,\n double tempOriginY,\n double tempWidth,\n double tempHeight,\n GraphicalWidget gw)\n {\n frameUI.setGraphicalWidgetBounds(tempOriginX,\n tempOriginY,\n tempWidth,\n tempHeight,\n gw);\n }","private void panelMouseReleased(java.awt.event.MouseEvent evt)\n throws Exception {\n\n /*This is the release point*/\n Point releasePoint = null;\n\n /*Check if something was selected and if the mouse was dragged*/\n if ((selectedShape != null)&& (mouseIsDragged)) {\n \n /*Get the current release Point*/\n releasePoint = evt.getPoint();\n\n /*Check if Shapes are within boundaries*/\n if (this.selectedShape instanceof ShapeConcept) {\n\n /*Check if the ShapeConcept is inside the canvas area*/\n offScreenShapeResize( ((ShapeConcept) selectedShape).getBounds());\n }//end ShapeConcept\n else if (this.selectedShape instanceof ShapeLinking) {\n\n /*Check if the ShapeConcept is inside the canvas area*/\n offScreenShapeResize( ((ShapeLinking) selectedShape).getBounds());\n }//end LinkingPhraze\n else if (this.selectedShape instanceof ShapeComment) {\n\n /*Check if the ShapeConcept is inside the canvas area*/\n offScreenShapeResize( ((ShapeComment) selectedShape).getBounds());\n }//end ShapeComment\n else if (this.selectedShape instanceof ShapeURL) {\n\n /*Check if the ShapeConcept is inside the canvas area*/\n offScreenShapeResize( ((ShapeURL) selectedShape).getBounds());\n }//end ShapeURL\n }//end if\n\n /**When mouse is released, finish dragging just reset values**/\n releasePoint = null;\n mouseIsDragged = false;\n //selectedShape = null;\n repaint();\n}"],"string":"[\n \"private void setSizeBox() {\\n\\t\\t\\tthis.leftX = pointsSubStroke.get(0).getX();\\n\\t\\t\\tthis.righX = pointsSubStroke.get(0).getX();\\n\\t\\t\\tthis.topY = pointsSubStroke.get(0).getY();\\n\\t\\t\\tthis.bottomY = pointsSubStroke.get(0).getY();\\n\\t\\t\\t\\n\\t\\t\\tfor(int i = 0; i < pointsSubStroke.size();i++) {\\n\\t\\t\\t\\tdouble x = pointsSubStroke.get(i).getX();\\n\\t\\t\\t\\tdouble y = pointsSubStroke.get(i).getX();\\n\\t\\t\\t\\t\\n\\t\\t\\t\\tthis.leftX = Math.min(x, leftX);\\n\\t\\t\\t\\tthis.righX = Math.max(x, righX);\\n\\t\\t\\t\\tthis.topY = Math.min(y, topY);\\n\\t\\t\\t\\tthis.bottomY = Math.max(y, bottomY);\\n\\t\\t\\t}\\n\\t\\t}\",\n \"public void updateTransform() {\\n \\t\\tif (viewBox != null) {\\n \\t\\t\\tOMSVGRect bbox = ((SVGRectElement)viewBox.getElement()).getBBox();\\n //\\t\\t\\tGWT.log(\\\"bbox = \\\" + bbox.getDescription());\\n \\t\\t\\tfloat d = (float)Math.sqrt((bbox.getWidth() * bbox.getWidth() + bbox.getHeight() * bbox.getHeight()) * 0.25) * scale * 2;\\n //\\t\\t\\tGWT.log(\\\"d = \\\" + d);\\n \\t\\t\\n \\t\\t\\t// Compute the actual canvas size. It is the max of the window rect\\n \\t\\t\\t// and the transformed bbox.\\n \\t\\t\\tfloat width = Math.max(d, windowRect.getWidth());\\n \\t\\t\\tfloat height = Math.max(d, windowRect.getHeight());\\n //\\t\\t\\tGWT.log(\\\"width = \\\" + width);\\n //\\t\\t\\tGWT.log(\\\"height = \\\" + height);\\n \\n \\t\\t\\t// Compute the display transform to center the image in the\\n \\t\\t\\t// canvas\\n \\t\\t\\tOMSVGMatrix m = svg.createSVGMatrix();\\n \\t\\t\\tfloat cx = bbox.getCenterX();\\n \\t\\t\\tfloat cy = bbox.getCenterY();\\n \\t\\t\\tm = m.translate(0.5f * (width - bbox.getWidth()) -bbox.getX(), 0.5f * (height - bbox.getHeight()) -bbox.getY())\\n \\t\\t\\t.translate(cx, cy)\\n \\t\\t\\t.rotate(angle)\\n \\t\\t\\t.scale(scale)\\n \\t\\t\\t.translate(-cx, -cy);\\n \\t\\t\\t((ISVGTransformable)xformGroup).getTransform().getBaseVal().getItem(0).setMatrix(m);\\n \\t\\t\\t((ISVGTransformable)modelGroup.getTwinWrapper()).getTransform().getBaseVal().getItem(0).setMatrix(m);\\n //\\t\\t\\tGWT.log(\\\"m=\\\" + m.getDescription());\\n \\t\\t\\tsvg.getStyle().setWidth(width, Unit.PX);\\n \\t\\t\\tsvg.getStyle().setHeight(height, Unit.PX);\\n \\t\\t}\\n \\t}\",\n \"public void transform() {\\n final var bounds = getParentBounds();\\n transform( bounds.width, bounds.height );\\n }\",\n \"private void updateViewBounds() \\r\\n {\\r\\n assert !sim.getMap().isEmpty() : \\\"Visualiser needs simulator whose a map has at least one node\\\"; \\r\\n \\r\\n \\r\\n viewMinX = minX * zoomFactor;\\r\\n viewMinY = minY * zoomFactor;\\r\\n \\r\\n viewMaxX = maxX * zoomFactor;\\r\\n viewMaxY = maxY * zoomFactor;\\r\\n \\r\\n \\r\\n double marginLength = zoomFactor * maxCommRange;\\r\\n \\r\\n \\r\\n // Set the size of the component\\r\\n int prefWidth = (int)Math.ceil( (viewMaxX - viewMinX) + (marginLength * 2) );\\r\\n int prefHeight = (int)Math.ceil( (viewMaxY - viewMinY) + (marginLength * 2) );\\r\\n setPreferredSize( new Dimension( prefWidth, prefHeight ) );\\r\\n \\r\\n \\r\\n // Adjust for margin lengths \\r\\n viewMinX -= marginLength;\\r\\n viewMinY -= marginLength;\\r\\n \\r\\n viewMaxX += marginLength;\\r\\n viewMaxY += marginLength;\\r\\n }\",\n \"@Override\\n public void componentResized(ComponentEvent e) {\\n setShape(new Ellipse2D.Double(0,0,FRAME_WIDTH,FRAME_WIDTH));\\n }\",\n \"public void updateBounds() {\\n this.setBounds(left, top, width, height);\\n }\",\n \"private void updateSize() {\\n double width = pane.getWidth();\\n double height = pane.getHeight();\\n\\n if(oldWidth == 0) {\\n oldWidth = width;\\n }\\n if(oldHeight == 0) {\\n oldHeight = height;\\n }\\n\\n double oldHvalue = pane.getHvalue();\\n double oldVvalue = pane.getVvalue();\\n if(Double.isNaN(oldVvalue)) {\\n oldVvalue = 0;\\n }\\n if(Double.isNaN(oldHvalue)) {\\n oldHvalue = 0;\\n }\\n\\n pane.setVmax(height);\\n pane.setHmax(width);\\n\\n if(grow) {\\n renderMapGrow(width, height, curZoom);\\n } else {\\n renderMap(width, height, curZoom);\\n }\\n\\n pane.setVvalue((height/oldHeight)*oldVvalue);\\n pane.setHvalue((width/oldWidth)*oldHvalue);\\n\\n oldWidth = width;\\n oldHeight = height;\\n }\",\n \"@Override\\n\\tpublic void componentResized(ComponentEvent e) {\\n\\t\\twidthAttitude=e.getComponent().getSize().getWidth()/Width;\\n\\t\\theightAttitude=e.getComponent().getSize().getHeight()/Height;\\n\\t}\",\n \"public void onBoundsResolved()\\n {\\n updateTransform();\\n }\",\n \"public void expand(){\\n\\t\\tsetBounds(getX()-getWidth()/4, getY(), getWidth() * 1.5f, getHeight());\\n\\t\\tcollisionBounds.setWidth(getWidth());\\n\\t}\",\n \"public void setFrameSize(double aWidth, double aHeight)\\n{\\n // If shape not rotated, scaled or skewed, just set and return\\n if(!isRSS()) {\\n if(_width<0) { setX(_x + (aWidth+_width)); aWidth = -aWidth; }\\n if(_height<0) { setY(_y + (aHeight+_height)); aHeight = -aHeight; }\\n setSize(aWidth, aHeight); return;\\n }\\n \\n // Convert X & Y axis to parent coords\\n RMSize x_axis = convertVectorToShape(new RMSize(_width, 0), _parent);\\n RMSize y_axis = convertVectorToShape(new RMSize(0, _height), _parent);\\n\\n // Scale widths of X & Y axes in parent coords by ratio of NewWidth/OldWidth\\n double sizeByRatio1 = Math.abs(aWidth)/(Math.abs(x_axis.width) + Math.abs(y_axis.width));\\n x_axis.width *= sizeByRatio1; y_axis.width *= sizeByRatio1;\\n \\n // Scale heights of X & Y axes in parent coords by ratio of NewHeight/OldHeight\\n double sizeByRatio2 = Math.abs(aHeight)/(Math.abs(x_axis.height) + Math.abs(y_axis.height));\\n x_axis.height *= sizeByRatio2; y_axis.height *= sizeByRatio2;\\n\\n // Cache current bounds origin (this shouldn't change)\\n RMPoint origin = getFrameXY();\\n \\n // Reset current Skew and convert X & Y axis from parent coords\\n setSkewXY(0, 0);\\n convertVectorFromShape(x_axis, _parent);\\n convertVectorFromShape(y_axis, _parent);\\n\\n // Set the size to compensate for the skew\\n setSize(x_axis.width, y_axis.height);\\n\\n // Calculate new skew angles (or roll, if width or height is zero)\\n if(width()==0)\\n setRoll(getRoll() - Math.toDegrees(Math.atan(y_axis.width/y_axis.height)));\\n else if(height()==0)\\n setRoll(getRoll() - Math.toDegrees(Math.atan(x_axis.height/x_axis.width)));\\n else {\\n setSkewX(Math.toDegrees(Math.atan(x_axis.height/x_axis.width)));\\n setSkewY(Math.toDegrees(Math.atan(y_axis.width/y_axis.height)));\\n }\\n\\n // Reset original bounds origin (it may have been effected by skew changes)\\n setFrameXY(origin);\\n}\",\n \"private void reCalculateFullExtent(){\\r\\n\\t\\tif (graphics.size() > 0) {\\r\\n\\t\\t\\tFGraphic g = (FGraphic) graphics.get(0);\\r\\n\\t\\t\\tfullExtent = g.getGeom().getEnvelope();\\r\\n\\t\\t\\tfor (int i = 1; i < graphics.size(); i++) {\\r\\n\\t\\t\\t\\tg = (FGraphic) graphics.get(i);\\r\\n\\t\\t\\t\\tEnvelope rAux = g.getGeom().getEnvelope();\\r\\n\\r\\n\\t\\t\\t\\tfullExtent.add(rAux);\\r\\n\\t\\t\\t}\\r\\n\\t\\t}\\r\\n\\t}\",\n \"@Override\\n public void onSizeChanged(int w, int h, int oldW, int oldH) {\\n // Set the movement bounds for the ballParent\\n box.set(0, 0, w, h);\\n }\",\n \"@Override\\npublic void basicDisplayBox(Point origin, Point corner) {\\n // do nothing\\n // we could transform all components proportionally\\n}\",\n \"private void updateBoxes(){\\n if(model.getMap() != null) {\\n DoubleVec position = invModelToView(new DoubleVec(canvas.getWidth()*0.5,canvas.getHeight()*0.5));\\n inner = new Rectangle(position, 1.0/zoomFactor * fi * canvas.getWidth(), 1.0/zoomFactor * fi * canvas.getHeight(), 0);\\n outer = new Rectangle(position, 1.0/zoomFactor * fo * canvas.getWidth(), 1.0/zoomFactor * fo * canvas.getHeight(), 0);\\n }\\n }\",\n \"public void zoomToAreaOfInterest() {\\n Envelope aoe = context.getViewport().getBounds();\\n if (aoe.getWidth() == 0) {\\n aoe.expandBy(.001, 0);\\n }\\n\\n if (aoe.getHeight() == 0) {\\n aoe.expandBy(0, .001);\\n }\\n Rectangle2D rect = new Rectangle2D.Double(aoe.getMinX(), aoe.getMinY(),\\n aoe.getWidth(), aoe.getHeight());\\n getCamera().animateViewToCenterBounds(rect, true, 0);\\n }\",\n \"Geometry getGeometry();\",\n \"@SuppressWarnings(\\\"unchecked\\\")\\n public void centralizarComponente() {\\n Dimension ds = Toolkit.getDefaultToolkit().getScreenSize();\\n Dimension dw = getSize();\\n setLocation((ds.width - dw.width) / 2, (ds.height - dw.height) / 2);\\n }\",\n \"@Override\\r\\n\\tprotected void onSizeChanged(int w, int h, int oldw, int oldh) {\\n\\t\\tfloat xPad = getPaddingLeft() + getPaddingRight();\\r\\n\\t\\tfloat yPad = getPaddingTop() + getPaddingBottom();\\r\\n\\t\\tdimension = Math.min(w - xPad, (h - yPad) * 2);\\r\\n\\t\\tradius = 60;\\r\\n\\t\\tinsideLeft = w / 2 - radius;\\r\\n\\t\\tinsideRight = w / 2 + radius;\\r\\n\\t\\tinsideTop = dimension - getPaddingBottom() - radius;\\r\\n\\t\\tinsideBottom = dimension - getPaddingBottom();\\r\\n\\t\\t\\r\\n//\\t\\toutRect = new RectF(getPaddingLeft(), getPaddingTop(), dimension - getPaddingRight(), dimension - getPaddingBottom());\\r\\n//\\t\\toutRect = new RectF(getPaddingLeft(), getPaddingTop(), dimension - getPaddingRight(), dimension/2);\\r\\n//\\t\\toutRect = new RectF(getPaddingLeft(), getPaddingTop(), dimension, dimension);\\r\\n\\t\\toutRect = new RectF(getPaddingLeft(), getPaddingTop(), w-getPaddingRight(), h-getPaddingBottom());\\r\\n\\t\\tfloat insideRectDownH = dimension-getPaddingBottom()-getPaddingTop()+150;\\r\\n//\\t\\tinsideRect = new RectF(50, 300, 320, insideRectDownH);\\r\\n\\t\\tinsideRect = new RectF(w/2-radius, dimension-radius, w/2+radius, dimension+radius);\\r\\n\\t}\",\n \"public void scaleAffine(){\\n //Get the monitors size.\\n Dimension screenSize = Toolkit.getDefaultToolkit().getScreenSize();\\n transform = new AffineTransform();\\n double width = screenSize.getWidth();\\n double height = screenSize.getHeight();\\n\\n //Set up the scale amount for our Affinetransform\\n double xscale = width / model.getBbox().getWidth();\\n double yscale = height / model.getBbox().getHeight();\\n\\n double scale = max(xscale, yscale);\\n\\n adjustZoomLvl(scale);\\n transform.translate(-model.getBbox().getMinX(), -model.getBbox().getMaxY());\\n\\n bounds = new CanvasBounds(getBounds(), transform);\\n adjustZoomFactor();\\n }\",\n \"protected void resizePanel() {\\n\\t\\tif (drawingAreaIsBlank) { // may have become blank after deleting the last node manually, so panel must still be shrunk\\n\\t\\t\\tsetPreferredSize(new Dimension(0,0)); // put back to small size so scrollbars disappear\\n\\t\\t\\trevalidate();\\n\\t\\t\\treturn;\\n\\t\\t}\\n\\t\\tgetMaxMin(); // get the extent of the tree to the left, right, bottom\\n\\t\\tsetPreferredSize(new Dimension(maxX, maxY));\\n\\t\\trevalidate();\\n\\t}\",\n \"@Override\\n\\tpublic void reshape(GLAutoDrawable glDrawable, int x, int y, int width, int height) {\\n\\t\\tGL2 gl = glDrawable.getGL().getGL2();\\n\\t\\t\\n\\t\\t// resize the ortho view\\n\\t\\t\\n\\t\\t// set the matrix mode to projection\\n\\t\\tgl.glMatrixMode(GL2.GL_PROJECTION);\\n\\t\\t// initialize the matrix\\n\\t\\tgl.glLoadIdentity();\\n\\t\\t// set the view to a 2D view\\n\\t\\tgl.glOrtho(-width / 2.0, width / 2.0, -height / 2.0, height / 2.0, 0, 1);\\n\\t\\t\\n\\t\\t// switch to the model view matrix\\n\\t\\tgl.glMatrixMode(GL2.GL_MODELVIEW);\\n\\t\\t// initialize the matrix\\n\\t\\tgl.glLoadIdentity();\\n\\t\\t\\n\\t\\t// set the size\\n\\t\\tthis.size = new Dimension(width, height);\\n\\t}\",\n \"@Override\\n public void reshape(GLAutoDrawable drawable, int x, int y, int width, int height) {\\n GL2 gl = drawable.getGL().getGL2(); // get the OpenGL 2 graphics context\\n\\n if (height == 0) height = 1; // prevent divide by zero\\n double aspect = (double)width / height;\\n\\n // Set the view port (display area) to cover the entire window\\n gl.glViewport(0, 0, width, height);\\n\\n // Setup perspective projection, with aspect ratio matches viewport\\n gl.glMatrixMode(GL_PROJECTION); // choose projection matrix\\n gl.glLoadIdentity(); // reset projection matrix\\n glu.gluPerspective(45.0, aspect, 0.1, 100.0); // fovy, aspect, zNear, zFar\\n\\n // Enable the model-view transform\\n gl.glMatrixMode(GL_MODELVIEW);\\n gl.glLoadIdentity(); // reset\\n }\",\n \"public void zoomToFit(RTGraphComponent.RenderContext myrc) {\\n RTGraphComponent.RenderContext original_myrc = myrc;\\n // Get the render context\\n if (myrc == null) myrc = (RTGraphComponent.RenderContext) (getRTComponent().getRTRenderContext()); if (myrc == null) return;\\n // Go through the entities... may be faster to iterate over visible entities...\\n Iterator it = entity_to_wxy.keySet().iterator(); if (it.hasNext() == false) return;\\n double x0 = Double.POSITIVE_INFINITY, y0 = Double.POSITIVE_INFINITY,\\n x1 = Double.NEGATIVE_INFINITY, y1 = Double.NEGATIVE_INFINITY;\\n // Check bounds for each one and adjust mins/maxes as appropriate\\n while (it.hasNext()) { \\n String str = it.next(); if (myrc.visible_entities.contains(str) == false) continue;\\n if (x0 > entity_to_wxy.get(str).getX()) x0 = entity_to_wxy.get(str).getX();\\n if (y0 > entity_to_wxy.get(str).getY()) y0 = entity_to_wxy.get(str).getY();\\n if (x1 < entity_to_wxy.get(str).getX()) x1 = entity_to_wxy.get(str).getX();\\n if (y1 < entity_to_wxy.get(str).getY()) y1 = entity_to_wxy.get(str).getY();\\n }\\n // Validate the output\\n if (Double.isInfinite(x0) || Double.isInfinite(y0)) return;\\n // Give it a border\\n if (x1 == x0) x1 = x0 + 0.5; if (y1 == y0) y1 = y0 + 0.5;\\n double xp = (x1 - x0)*0.05, yp = (y1 - y0)*0.05;\\n // Transform and redraw\\n if (getGraphBG() == GraphBG.GEO_OUT || getGraphBG() == GraphBG.GEO_FILL || getGraphBG() == GraphBG.GEO_TOUCH) {\\n if (x0 > -180) { x0 = -180; xp = 0.0; }\\n if (y0 > -90) { y0 = -90; yp = 0.0; }\\n if (x1 < 180) { x1 = 180; xp = 0.0; }\\n if (y1 < 90) { y1 = 90; yp = 0.0; }\\n }\\n extents = new Rectangle2D.Double(x0-xp,y0-yp,x1-x0+2*xp,y1-y0+2*yp);\\n transform(); if (original_myrc == null) getRTComponent().render();\\n }\",\n \"void setBounds(double x, double y, double scale) {\\n double drawAspect = (double)width / (double)height;\\n\\n double halfPlotWidth = scale / 2.0;\\n double halfPlotHeight = scale / 2.0;\\n if (drawAspect > 1.0) {\\n halfPlotWidth *= drawAspect;\\n } else {\\n halfPlotHeight /= drawAspect;\\n }\\n\\n setBounds(x - halfPlotWidth, y - halfPlotHeight, x + halfPlotWidth, y + halfPlotHeight);\\n }\",\n \"private void drag() {\\n Point mousePosition = calculateMouseLocation();\\n getArea().x = mousePosition.getX() - (mouseX - prevX);\\n getArea().y = mousePosition.getY() - (mouseY - prevY);\\n // Ensure that weird resizing stuff doesn't happen while moving the\\n // window. Idfk why this works, but it does.\\n resize();\\n getLayout().resize(this, getChildren());\\n getLayout().layout(this, getChildren());\\n }\",\n \"public void reshape(int x, int y, int w, int h) {\\n size.width = w;\\n size.height = h;\\n }\",\n \"protected Rectangle getSelectedElementFigureArea()\\n {\\n boolean anchored = false;\\n\\n // Use figures since they may be sized differently during dynamics\\n // accumulate as unzoomed.\\n Rectangle r = null;\\n\\n // Go through the list of selected widget figures, union the bounds.\\n Iterator> iter = selection.getSelectedFigures();\\n\\n while (iter.hasNext()) {\\n FrameEltSelnFig fig = iter.next();\\n\\n if (fig instanceof GraphicalWidget) {\\n GraphicalWidget gw = (GraphicalWidget) fig;\\n IWidget w = gw.getModel();\\n SimpleWidgetGroup wg = w.getParentGroup();\\n\\n if (wg != null) {\\n r = unionBounds(r, getGroupFigureBounds(wg));\\n anchored = anchored || (w instanceof ChildWidget);\\n }\\n else {\\n r = unionBounds(r, gw.getBounds());\\n }\\n }\\n else if (fig instanceof FrameEltGroupHalo) {\\n Rectangle haloBds = fig.getBounds(); // this is zoomed!\\n double scale = frameUI.getZoom();\\n\\n double right = (haloBds.x + haloBds.width) / scale;\\n double bottom = (haloBds.y + haloBds.height) / scale;\\n double left = haloBds.x / scale;\\n double top = haloBds.y / scale;\\n\\n haloBds =\\n PrecisionUtilities.getDraw2DRectangle(left,\\n top,\\n right - left,\\n bottom - top);\\n\\n r = unionBounds(r, haloBds);\\n }\\n }\\n\\n setTopLeftAnchored(anchored);\\n\\n return r;\\n }\",\n \"protected void calculateBounds()\\r\\n {\\r\\n Toolkit DefaultToolkit = Toolkit.getDefaultToolkit();\\r\\n Dimension ScreenSize = DefaultToolkit.getScreenSize();\\r\\n int FrameWidth = ScreenSize.width - 100;\\r\\n int FrameHeight = ScreenSize.height - 100;\\r\\n setBounds(50, 50, FrameWidth, FrameHeight);\\r\\n }\",\n \"public void updateCoords() {\\n line.setLine(parent.getFullBounds().getCenter2D(), child.getFullBounds().getCenter2D());\\n Rectangle2D r = line.getBounds2D();\\n // adding 1 to the width and height prevents the bounds from\\n // being marked as empty and is much faster than createStrokedShape()\\n setBounds(r.getX(), r.getY(), r.getWidth() + 1, r.getHeight() + 1);\\n invalidatePaint();\\n }\",\n \"@Override\\n protected void onSizeChanged (int w, int h, int oldw, int oldh) {\\n mXSize = w;\\n mYSize = h;\\n\\n mZBoundOut = new RectF(w/2-w/2.5f, h/2-w/2.5f, w/2+w/2.5f, h/2+w/2.5f);\\n mZBoundOut2 = new RectF(\\n w/2-w/2.5f-ZRING_CURSOR_ADD, h/2-w/2.5f-ZRING_CURSOR_ADD,\\n w/2+w/2.5f+ZRING_CURSOR_ADD, h/2+w/2.5f+ZRING_CURSOR_ADD);\\n mZBoundIn = new RectF(\\n w/2-w/2.5f+ZRING_WIDTH, h/2-w/2.5f+ZRING_WIDTH,\\n w/2+w/2.5f-ZRING_WIDTH, h/2+w/2.5f-ZRING_WIDTH);\\n mZBoundIn2 = new RectF(\\n w/2-w/2.5f+ZRING_WIDTH+ZRING_CURSOR_ADD, h/2-w/2.5f+ZRING_WIDTH+ZRING_CURSOR_ADD,\\n w/2+w/2.5f-ZRING_WIDTH-ZRING_CURSOR_ADD, h/2+w/2.5f-ZRING_WIDTH-ZRING_CURSOR_ADD);\\n\\n if (LOCAL_LOGV) Log.v(TAG, \\\"New view size = (\\\"+w+\\\", \\\"+h+\\\")\\\");\\n }\",\n \"public void centerSelection() {\\n RenderContext myrc = (RenderContext) rc; if (myrc == null) return;\\n Set sel = myrc.filterEntities(getRTParent().getSelectedEntities());\\n if (sel != null && sel.size() > 0) {\\n Iterator it = sel.iterator();\\n\\twhile (it.hasNext()) { \\n\\t String ent = it.next(); Point2D point = entity_to_wxy.get(ent);\\n\\t if (last_shft_down) entity_to_wxy.put(ent, new Point2D.Double(point.getX(),m_wy)); \\n\\t else if (last_ctrl_down) entity_to_wxy.put(ent, new Point2D.Double(m_wx,point.getY()));\\n\\t else entity_to_wxy.put(ent, new Point2D.Double(m_wx,m_wy));\\n\\t transform(ent); \\n\\t}\\n getRTComponent().render();\\n }\\n }\",\n \"public void updateBounds(){\\r\\n\\t\\tRectangle bounds = new Rectangle(super.getBounds());\\r\\n\\t\\tint preferredHeight = 0;\\r\\n\\t\\tfor(Object child : getChildren()){\\r\\n\\t\\t\\tIFigure figure = (IFigure)child;\\r\\n\\t\\t\\tpreferredHeight += figure.getPreferredSize().height;\\r\\n\\t\\t}\\r\\n\\t\\tif (preferredHeight == 0) preferredHeight = 200;\\r\\n\\t\\tbounds.setHeight(preferredHeight+20);\\r\\n\\t\\tsetBounds(bounds);\\r\\n\\t}\",\n \"public void componentResized(ComponentEvent e) {\\n myReshape(getSize().width, getSize().height);\\n display();\\n repaint();\\n }\",\n \"public void componentResized(ComponentEvent e) {\\n myReshape(getSize().width, getSize().height);\\n display();\\n repaint();\\n }\",\n \"@Override\\r\\n\\tprotected void initShape() {\\n\\t\\tgetPositions().putAll(createSymmetricLines(0, 1.5, .5, 1.1, WingPart.OUTER_LEFT, WingPart.OUTER_RIGHT));\\r\\n\\t\\t//->upper corner\\r\\n\\t\\tgetPositions().putAll(createSymmetricLines(.5, 1.1, 1, .7, WingPart.OUTER_LEFT, WingPart.OUTER_RIGHT));\\r\\n\\t\\t//-> lower outer corner\\r\\n\\t\\tgetPositions().putAll(createSymmetricLines(1, .7, 1.1, .3, WingPart.OUTER_LEFT, WingPart.OUTER_RIGHT));\\r\\n\\t\\t//-> lower inner corner\\r\\n\\t\\tgetPositions().putAll(createSymmetricLines(1.1, .3, .7, .25, WingPart.OUTER_LEFT, WingPart.OUTER_RIGHT));\\r\\n\\t\\t//-> middle\\r\\n\\t\\tgetPositions().putAll(createSymmetricLines(.7, .25, .2, 1.35, WingPart.OUTER_LEFT, WingPart.OUTER_RIGHT));\\r\\n\\t\\t//inner\\r\\n\\t\\tgetPositions().putAll(createSymmetricLines(1, .5, .55, 0.95, WingPart.INNER_LEFT, WingPart.INNER_RIGHT));\\r\\n\\t\\tgetPositions().putAll(createSymmetricLines(0.8, .4, .55, 0.95, WingPart.INNER_LEFT, WingPart.INNER_RIGHT));\\r\\n\\t\\tgetPositions().putAll(createSymmetricPoints(0.9, .5, WingPart.INNER_LEFT, WingPart.INNER_RIGHT));\\r\\n\\r\\n//\\t\\tgetPositions().putAll(fill(WingPart.OUTER_RIGHT, WingPart.INNER_RIGHT));\\r\\n//\\t\\tgetPositions().putAll(fill(WingPart.OUTER_LEFT, WingPart.INNER_LEFT));\\r\\n\\t}\",\n \"@Override\\n public void componentResized(ComponentEvent e) {\\n window.setShape(new Ellipse2D.Double(0, 0, window.getWidth(), window.getHeight()));\\n window.add(panel);\\n window.setLocation((screenSize.width - window.getSize().width) / 2, (screenSize.height - window.getSize().height) / 2);\\n window.setVisible(true);\\n }\",\n \"public void updateRenderRect() {\\n int i = 0;\\n if (this.mTargetRatio == 2) {\\n this.mTx = this.mRenderWidth == 0 ? 0 : (this.mRenderOffsetX * this.mSurfaceWidth) / this.mRenderWidth;\\n int i2 = (this.mSurfaceHeight - this.mSurfaceWidth) / 2;\\n if (this.mRenderHeight != 0) {\\n i = (this.mRenderOffsetY * this.mSurfaceHeight) / this.mRenderHeight;\\n }\\n this.mTy = i2 + i;\\n this.mTwidth = this.mSurfaceWidth;\\n this.mTheight = this.mSurfaceWidth;\\n this.mRenderLayoutRect.set(this.mRenderOffsetX, ((this.mRenderHeight - this.mRenderWidth) / 2) + this.mRenderOffsetY, this.mRenderWidth + this.mRenderOffsetX, ((this.mRenderHeight - this.mRenderWidth) / 2) + this.mRenderOffsetY + this.mRenderWidth);\\n return;\\n }\\n this.mTx = this.mRenderWidth == 0 ? 0 : (this.mRenderOffsetX * this.mSurfaceWidth) / this.mRenderWidth;\\n this.mTy = this.mRenderHeight == 0 ? 0 : (this.mRenderOffsetY * this.mSurfaceHeight) / this.mRenderHeight;\\n this.mTwidth = this.mSurfaceWidth;\\n this.mTheight = this.mSurfaceHeight;\\n this.mRenderLayoutRect.set(0, 0, this.mRenderWidth, this.mRenderHeight);\\n }\",\n \"public void update() {\\n\\t\\tactSX=parent.actSX*scaleX;\\n\\t\\tactSY=parent.actSY*scaleY;\\n\\t\\tw=posW*actSX;\\n\\t\\th=posH*actSY;\\n\\t\\tswitch (align) {\\n\\t\\tcase DEFAULT:\\n\\t\\t\\tx=parent.x+posX*actSX;\\n\\t\\t\\ty=parent.y+posY*actSY;\\n\\t\\t\\tbreak;\\n\\t\\tcase TOPRIGHT:\\n\\t\\t\\tx=parent.x+parent.w-(posX+posW)*actSX;\\n\\t\\t\\ty=parent.y+posY*actSY;\\n\\t\\t\\tbreak;\\n\\t\\tcase BOTTOMLEFT:\\n\\t\\t\\tx=parent.x+posX*actSX;\\n\\t\\t\\ty=parent.y+parent.h-(posY+posH)*actSY;\\n\\t\\t\\tbreak;\\n\\t\\tcase BOTTOMRIGHT:\\n\\t\\t\\tx=parent.x+parent.w-(posX+posW)*actSX;\\n\\t\\t\\ty=parent.y+parent.h-(posY+posH)*actSY;\\n\\t\\t\\tbreak;\\n\\t\\tcase CENTEREDX:\\n\\t\\t\\tx=parent.x+parent.w/2-w/2+posX*actSX;\\n\\t\\t\\ty=parent.y+posY*actSY;\\n\\t\\t\\tbreak;\\n\\t\\tcase CENTEREDY:\\n\\t\\t\\tx=parent.x+posX*actSX;\\n\\t\\t\\ty=parent.y+parent.h/2-h/2+posY*actSY;\\n\\t\\t\\tbreak;\\n\\t\\tcase CENTEREDXY:\\n\\t\\t\\tx=parent.x+parent.w/2-w/2+posX*actSX;\\n\\t\\t\\ty=parent.y+parent.h/2-h/2+posY*actSY;\\n\\t\\t\\tbreak;\\n\\t\\t}\\n\\t}\",\n \"protected void update(Rectangle r)\\n {\\n if ((r != null) &&\\n (bottomRightResize != null) &&\\n bottomRightResize.isVisible())\\n {\\n // Since the resize rects are not drawn in the zoomed area\\n // calculate the positions in the unzoomed context\\n double scale = frameUI.getZoom();\\n\\n // Center on corners. These figures are not \\\"scaled\\\" they must\\n // be positioned in SCALED location, not in 1:1 location.\\n double right = r.x + r.width;\\n double bottom = r.y + r.height;\\n\\n int x = PrecisionUtilities.round(r.x * scale);\\n int y = PrecisionUtilities.round(r.y * scale);\\n int width = PrecisionUtilities.round(right * scale) - x;\\n int height = PrecisionUtilities.round(bottom * scale) - y;\\n\\n // Trigger a redraw on all handles.\\n if (topLeftResize.isVisible()) {\\n topLeftResize.centerAt(x, y);\\n topLeftResize.repaint();\\n }\\n\\n bottomLeftResize.centerAt(x, y + height);\\n bottomLeftResize.repaint();\\n\\n topRightResize.centerAt(x + width, y);\\n topRightResize.repaint();\\n\\n bottomRightResize.centerAt(x + width, y + height);\\n bottomRightResize.repaint();\\n }\\n }\",\n \"@Override\\r\\n\\tpublic void onSizeChanged(int w, int h, int oldW, int oldH) {\\r\\n\\t\\t// Set the movement bounds for the ball\\r\\n\\t\\txMax = w - 1;\\r\\n\\t\\tyMax = h - 1;\\r\\n\\t}\",\n \"public void mouseDragged(MouseEvent e) {\\r\\n Graphics g = view.getViewJComponent().getGraphics();\\r\\n rectangle.setSize(Math.abs(e.getX() - rectangle.x),\\r\\n Math.abs(e.getY() - rectangle.y));\\r\\n view.getViewJComponent().repaint();\\r\\n g.drawRect(rectangle.x, rectangle.y, rectangle.width,\\r\\n rectangle.height);\\r\\n }\",\n \"public void calculateWindow()\\n {\\n Vector2 windowBottomLeftBounds = new Vector2(1000000, 1000000);\\n Vector2 windowTopRightBounds = new Vector2(-1000000, -1000000);\\n for (Element e : children())\\n {\\n if (e.id() != null && (e.id().startsWith(id() + \\\"hBar\\\") || e.id().startsWith(id() + \\\"vBar\\\")))\\n {\\n continue;\\n }\\n for (Element child : e)\\n {\\n Vector2 alignmentVector = child.alignment().alignmentVector();\\n Vector2 bottomLeftBounds = new Vector2(child.x() - (alignmentVector.x * child.width()), child.y()\\n - (alignmentVector.y * child.height()));\\n Vector2 topRightBounds = new Vector2(bottomLeftBounds.x + child.width(), bottomLeftBounds.y + child.height());\\n // left\\n if (windowBottomLeftBounds.x > bottomLeftBounds.x)\\n {\\n windowBottomLeftBounds.x = bottomLeftBounds.x;\\n }\\n // bottom\\n if (windowBottomLeftBounds.y > bottomLeftBounds.y)\\n {\\n windowBottomLeftBounds.y = bottomLeftBounds.y;\\n }\\n // right\\n if (windowTopRightBounds.x < topRightBounds.x)\\n {\\n windowTopRightBounds.x = topRightBounds.x;\\n }\\n // top\\n if (windowTopRightBounds.y < topRightBounds.y)\\n {\\n windowTopRightBounds.y = topRightBounds.y;\\n }\\n }\\n }\\n \\n content = new CRectangle(windowBottomLeftBounds.x, windowBottomLeftBounds.y, windowTopRightBounds.x - windowBottomLeftBounds.x,\\n windowTopRightBounds.y - windowBottomLeftBounds.y);\\n content.origin = new Vector2(0, 0);\\n \\n calculateScrollSize();\\n }\",\n \"@Override\\n\\tpublic void mouseDragged(MouseEvent e) {\\n\\t\\tif(scale != 1.0) {\\n\\t\\t\\tPoint2D.Double view = new Point2D.Double(e.getX(), e.getY());\\n\\t\\t\\tPoint2D.Double worldPoint = new Point2D.Double();\\n\\t\\t\\tAffineTransform viewToWorld = new AffineTransform(1.0 / scale, 0, 0, 1.0 / scale, worldUpperLeft.getX(), worldUpperLeft.getY());\\n\\t\\t\\tviewToWorld.transform(view, worldPoint);\\n\\t\\t\\t\\n\\t\\t\\twX = worldPoint.getX();\\n\\t\\t\\twY = worldPoint.getY();\\n\\t\\n\\t\\t\\tdouble diffX = wDragStartX - wX;\\n\\t\\t\\tdouble diffY = wDragStartY - wY;\\n\\t\\t\\tdouble wulX = worldUpperLeft.getX();\\n\\t\\t\\tdouble wulY = worldUpperLeft.getY();\\n\\t\\t\\tdouble newUpX = diffX + wulX;\\n\\t\\t\\tdouble newUpY = diffY + wulY;\\n\\t\\t\\t\\n\\t\\t\\tif(newUpX < 0)\\n\\t\\t\\t\\tnewUpX = 0;\\n\\t\\t\\tif(newUpY < 0)\\n\\t\\t\\t\\tnewUpY = 0;\\n\\t\\t\\tif(scale == 2.0 && newUpX > 512)\\n\\t\\t\\t\\tnewUpX = 512;\\n\\t\\t\\tif(scale == 2.0 && newUpY > 512)\\n\\t\\t\\t\\tnewUpY = 512;\\n\\t\\t\\tif(scale == 4.0 && newUpX > 768)\\n\\t\\t\\t\\tnewUpX = 768;\\n\\t\\t\\tif(scale == 4.0 && newUpY > 768)\\n\\t\\t\\t\\tnewUpY = 768;\\n\\t\\t\\t\\n\\t\\t\\tworldUpperLeft = new Point2D.Double(newUpX, newUpY);\\n\\t\\t\\t\\n\\t\\t\\tif(worldUpperLeft.getX() + scrollbarSize > MAXSCROLLBARSIZE) \\n\\t\\t\\t\\tGUIFunctions.setHScrollBarPosit(MAXSCROLLBARSIZE - scrollbarSize);\\n\\t\\t\\telse \\n\\t\\t\\t\\tGUIFunctions.setHScrollBarPosit((int) worldUpperLeft.getX());\\n\\t\\t\\t\\n\\t\\t\\tif(worldUpperLeft.getY() + scrollbarSize > MAXSCROLLBARSIZE) \\n\\t\\t\\t\\tGUIFunctions.setVScrollBarPosit(MAXSCROLLBARSIZE - scrollbarSize);\\n\\t\\t\\telse \\n\\t\\t\\t\\tGUIFunctions.setVScrollBarPosit((int) worldUpperLeft.getY());\\n\\t\\t\\tGUIFunctions.refresh();\\n\\t\\t}\\n\\t}\",\n \"private void adjustEViewPosition() {\\n double aVec[] = theRocket.getCoordSys().getPositionVec();\\n CoordSys eViewSys = new CoordSys();\\n eViewSys.setZAxis(VMath.normalize(aVec));\\n\\n aVec = VMath.vecMultByScalar(aVec, 2.5);\\n eViewSys.setPositionAsVec(aVec);\\n\\n double[] zAxis = VMath.normalize(eViewSys.zAxis().getVectorForm());\\n double[] yAxis = VMath.normalize(theRocket.getCoordSys().yAxis().getVectorForm());\\n double[] xAxis = VMath.normalize(VMath.crossprd(yAxis, zAxis));\\n yAxis = VMath.crossprd(zAxis, xAxis);\\n eViewSys.setXAxis(xAxis);\\n eViewSys.setYAxis(yAxis);\\n eViewSys.setZAxis(zAxis);\\n\\n eViewSys.xRotate(180);\\n eViewSys.zRotate(-90);\\n eView.setViewingCoordSys(eViewSys);\\n }\",\n \"@Override\\n\\tprotected void onSizeChanged(int w, int h, int oldw, int oldh) {\\n\\t\\tsuper.onSizeChanged(w, h, oldw, oldh);\\n\\t\\tif( mr > 0.1f*h ) {\\n\\t\\t\\tmr=0.1f*h;\\n\\t\\t\\tif( m != null ) {\\n\\t\\t\\t\\t((CircleObjectKE)m).setR(mr);\\n\\t\\t\\t}\\n\\t\\t}\\n\\t}\",\n \"public void reshape(GLAutoDrawable drawable, int x, int y, int width, int height) {\\n winW = width;\\n winH = height;\\n\\n gl.glViewport(0, 0, width, height);\\n}\",\n \"@Override\\n public void setBounds(Rectangle bounds) {\\n final Rectangle repaintBounds = new Rectangle(getBounds());\\n\\n final Rectangle newBounds = new Rectangle(ajustOnGrid(bounds.x),\\n ajustOnGrid(bounds.y), ajustOnGrid(bounds.width), bounds.height);\\n\\n newBounds.width = newBounds.width < MINIMUM_SIZE.x ? MINIMUM_SIZE.x\\n : newBounds.width;\\n\\n this.bounds = newBounds;\\n\\n parent.getScene().repaint(repaintBounds);\\n parent.getScene().repaint(newBounds);\\n\\n // Move graphics elements associated with this component\\n leftMovableSquare.setBounds(computeLocationResizer(0));\\n rightMovableSquare.setBounds(computeLocationResizer(bounds.width));\\n\\n setChanged();\\n notifyObservers();\\n }\",\n \"@Override\\n public void reshape(GLAutoDrawable drawable, int x, int y, int width, int height) {\\n // Get OpenGL context\\n gl = drawable.getGL().getGL2();\\n\\n // Prevent zero height to stop divide by zero errors\\n if (height == 0) {\\n height = 1;\\n }\\n float aspect = (float) width / height;\\n\\n // Set the view port (display area) to cover the entire window\\n gl.glViewport(0, 0, width, height);\\n\\n // Setup perspective projection, with aspect ratio matches viewport\\n gl.glMatrixMode(GL_PROJECTION);\\n gl.glLoadIdentity();\\n glu.gluPerspective(45.0, aspect, 0.1, 100.0);\\n\\n // Enable the model-view transform\\n gl.glMatrixMode(GL_MODELVIEW);\\n gl.glLoadIdentity();\\n }\",\n \"public void updateDisplayBounds() {\\n if (display_.getDataSource().getBounds() != null) {\\n int[] newBounds = display_.getDataSource().getBounds();\\n int[] oldBounds = display_.getDisplayModel().getBounds();\\n double xResize = (oldBounds[2] - oldBounds[0]) / (double) (newBounds[2] - newBounds[0]);\\n double yResize = (oldBounds[3] - oldBounds[1]) / (double) (newBounds[3] - newBounds[1]);\\n setImageBounds(newBounds);\\n if (xResize < 1 || yResize < 1) {\\n zoom(1 / Math.min(xResize, yResize), null);\\n }\\n }\\n }\",\n \"@Override\\n\\tpublic void geometry(Geometry geometry) {\\n\\t\\t\\n\\t}\",\n \"@As( \\\"figure with dimensions x: $, y: $, width: $, height: $\\\" )\\n void figure(double x, double y, double width, double height) {\\n figure = new SVGRectFigure(x,y,width,height);\\n handles.clear();\\n ResizeHandleKit.addEdgeResizeHandles(figure,handles);\\n ResizeHandleKit.addCornerResizeHandles(figure, handles);\\n setUpView();\\n }\",\n \"public abstract Geometry computeGeometry();\",\n \"@Override\\r\\n public Dimension getPreferredSize() {\\n \\r\\n return new Dimension((int) (this.getHeight() * 0.8), this.getHeight());\\r\\n }\",\n \"@Override\\r\\n\\tprotected void pack() {\\r\\n\\r\\n\\t\\tRectangle displayarea = shell.getDisplay().getPrimaryMonitor().getBounds();\\r\\n\\t\\tRectangle windowarea = shell.getBounds();\\r\\n\\t\\tshell.setBounds((displayarea.width - windowarea.width) / 2,\\r\\n\\t\\t\\t\\t(displayarea.height - windowarea.height) / 2,\\r\\n\\t\\t\\t\\twindowarea.width, windowarea.height);\\r\\n\\t}\",\n \"public void setPosicao() {\\n Dimension d = this.getDesktopPane().getSize();\\n this.setLocation((d.width - this.getSize().width) / 2, (d.height - this.getSize().height) / 2); \\n}\",\n \"@Override\\n public void updateCenter(int newX, int newY) {\\n Point oldCenter = wrappedPolygon.getCenterPoint();\\n wrappedPolygon.translate(newX - oldCenter.x, newY - oldCenter.y);\\n }\",\n \"public Window() {\\n // Creation de la fenetre\\n super();\\n\\n // Creation du graphe de scene\\n sceneGraph = new SceneGraph(\\\"Scene Graph\\\");\\n origin = new int[2];\\n\\n // Proprietes generales de la fenetre\\n // Titre de la fenetre\\n this.setTitle(NOMFENETRE);\\n /// Taille de la fenetre\\n this.setSize(HTAILLE, VTAILLE);\\n // Centre la fenetre a l'ecran\\n this.setLocationRelativeTo(null);\\n // Pour fermer la fenetre lorsqu'on clique sur la croix\\n this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);\\n\\n // Creation des composants de la fenetre\\n infoBar = new InfoBar();\\n treeZone = new TreePanel();\\n drawZone = new DrawPanel(infoBar, treeZone);\\n optionZone = new OptionPanel(drawZone);\\n menuBar = new MenuBar();\\n toolBar = new ToolBar(optionZone);\\n\\n split = new JSplitPane(JSplitPane.HORIZONTAL_SPLIT, treeZone, drawZone);\\n split.setDividerLocation(200);\\n\\n treeZone.initializeListeners(drawZone);\\n menuBar.initializeListeners(drawZone);\\n\\n // Ajout de la barre de menu a la fenetre\\n this.setJMenuBar(menuBar);\\n // Ajout des differents sous-conteneurs au conteneur principal\\n this.getContentPane().setLayout(new BorderLayout());\\n this.add(optionZone, BorderLayout.NORTH);\\n this.add(toolBar, BorderLayout.WEST);\\n this.add(split, BorderLayout.CENTER);\\n this.add(infoBar, BorderLayout.SOUTH);\\n\\n // Affiche la fenetre a l'ecran\\n this.setVisible(true);\\n\\n this.addComponentListener(new ComponentAdapter() {\\n\\n @Override\\n public void componentResized(ComponentEvent e) {\\n drawZone.calculateOrigin();\\n }\\n });\\n\\n }\",\n \"public void updateOverviewCanvas() {\\n\\t\\tif (m_mapImage.getImageHeight() == 0 || m_mapImage.getImageWidth() == 0) {\\n\\t\\t\\treturn;\\n\\t\\t}\\n\\t\\t\\n\\t\\t// What are the extents of a visible canvas in the ScrollPane/Pane?\\n\\n\\t\\t// The bound box changes with dragging\\n\\t\\tBounds b = m_zoomPane.getCanvas().getBoundsInParent();\\n\\n\\t\\t// The bound box doesn't change with zoom\\n\\t\\tdouble scale = m_zoomPane.getScale();\\n\\t\\t\\n\\t\\t// System.out.println(b.getMinX() + \\\" \\\" + b.getMinY() + \\\" \\\" + b.getMaxX() + \\\" \\\" + b.getMaxY() + \\\" \\\" + scale);\\n\\t\\t\\n\\t\\t// At start, 0.0 and 0.0 is the canvas translation, scale is 1.0\\n\\t\\t// Other bounds describe the overall dimensions.\\n\\t\\t\\n\\t\\t// I need to know the size of the viewport\\n\\t\\t// Then offset that viewport with b.getMinX() and b.getMinY()\\n\\t\\t// And consider the scale factor!\\n\\t\\tBounds sp = scrollPane.getBoundsInLocal();\\n\\n\\t\\t// Determine a scale based on what is needed to fit vertically or horizontally into the Canvas.\\n\\t\\tdouble widthRatio = (double) MAX_OVERVIEW_WIDTH / (double) m_mapImage.getImageWidth();\\n\\t\\tdouble heightRatio = (double) MAX_OVERVIEW_HEIGHT / (double) m_mapImage.getImageHeight();\\n\\t\\t\\n\\t\\tdouble scaleFactor = widthRatio < heightRatio ? widthRatio : heightRatio;\\n\\t\\t\\n\\t\\t// Set the transform\\n\\t\\tAffine mat = new Affine(new Scale (scaleFactor, scaleFactor));\\n\\t\\t\\n\\t\\tGraphicsContext gc = m_navigationCanvas.getGraphicsContext2D();\\n\\t\\tgc.clearRect(0, 0, m_navigationCanvas.getWidth(), m_navigationCanvas.getHeight());\\n\\t\\t\\n\\t\\t// Draw image\\n\\t\\tm_mapImage.drawImage(m_navigationCanvas, mat, false);\\n\\t\\t\\n\\t\\t// Draw bounding box\\n\\t\\t// TODO: ugh, this is almost correct but its behaving oddly with the left corner X/Y.\\n\\t\\tdouble dx = (sp.getMaxX() - sp.getMaxX() / scale) / 2;\\n\\t\\tdouble dy = (sp.getMaxY() - sp.getMaxY() / scale) / 2;\\n\\t\\t\\n\\t\\t// double box_xl = - b.getMinX();\\n\\t\\t// double box_yl = - b.getMinY();\\n\\t\\t// double box_xr = - b.getMinX() + sp.getMaxX() / scale;\\n\\t\\t// double box_yr = - b.getMinY() + sp.getMaxY() / scale;\\n\\t\\t\\n\\t\\tdouble box_xl = - b.getMinX() + dx;\\n\\t\\tdouble box_yl = - b.getMinY() + dy;\\n\\t\\tdouble box_xr = - b.getMinX() + sp.getMaxX() / scale + dx;\\n\\t\\tdouble box_yr = - b.getMinY() + sp.getMaxY() / scale + dy;\\n\\t\\t\\n\\t\\t// Clamp to limit the min/max view boxes.\\n\\t\\t//if (box_xl < 0) box_xl = 0;\\n\\t\\t//if (box_yl < 0) box_yl = 0;\\n\\t\\t//if (box_xr > m_navigationCanvas.getWidth()) box_xr = m_navigationCanvas.getWidth();\\n\\t\\t//if (box_yr > m_navigationCanvas.getHeight()) box_yr = m_navigationCanvas.getHeight();\\n\\t\\t\\n\\t\\t// Let's describe how the viewport would be in the canvas.\\n\\t\\tVector3 pt1 = m_zoomPane.getActualPixelPosition(box_xl, box_yl);\\n\\t\\tVector3 pt2 = m_zoomPane.getActualPixelPosition(box_xl, box_yr);\\n\\t\\tVector3 pt3 = m_zoomPane.getActualPixelPosition(box_xr, box_yr);\\n\\t\\tVector3 pt4 = m_zoomPane.getActualPixelPosition(box_xr, box_yl);\\n\\t\\t\\n\\t\\t// Save the transform state\\n\\t\\tgc.save();\\n gc.setTransform(mat);\\n \\n\\t\\tColor c = Color.RED;\\n // Draw some lines.\\n\\t\\tgc.beginPath();\\n\\t\\tgc.setStroke(c);\\n\\t\\tgc.setFill(c);\\n\\t\\tgc.setLineWidth(1.0 / scaleFactor);\\n\\t\\t\\n gc.moveTo(pt1.x, pt1.y);\\n gc.lineTo(pt2.x, pt2.y);\\n gc.moveTo(pt2.x, pt2.y);\\n gc.lineTo(pt3.x, pt3.y);\\n \\n gc.moveTo(pt3.x, pt3.y);\\n gc.lineTo(pt4.x, pt4.y);\\n gc.moveTo(pt4.x, pt4.y);\\n gc.lineTo(pt1.x, pt1.y);\\n \\n gc.stroke();\\n gc.closePath();\\n \\n gc.restore();\\n\\t}\",\n \"@Override\\r\\npublic void componentResized(ComponentEvent arg0) {\\n\\tsetSizeBackgr(getSize());\\r\\n\\tsetSizeHat (getSize());\\r\\n\\tsetSizeGift(getSize());\\r\\n}\",\n \"private void applyWindowToViewportTransformation(Graphics2D g2,\\n double left, double right, double bottom, double top,\\n boolean preserveAspect) {\\n int width = getWidth();\\n int height = getHeight();\\n if (preserveAspect) {\\n double displayAspect = Math.abs((double) height / width);\\n double requestedAspect = Math.abs((bottom - top) / (right - left));\\n if (displayAspect > requestedAspect) {\\n double excess = (bottom - top) * (displayAspect / requestedAspect - 1);\\n bottom += excess / 2;\\n top -= excess / 2;\\n } else if (displayAspect < requestedAspect) {\\n double excess = (right - left) * (requestedAspect / displayAspect - 1);\\n right += excess / 2;\\n left -= excess / 2;\\n }\\n }\\n g2.scale(width / (right - left), height / (bottom - top));\\n g2.translate(-left, -top);\\n double pixelWidth = Math.abs((right - left) / width);\\n double pixelHeight = Math.abs((bottom - top) / height);\\n pixelSize = (float) Math.max(pixelWidth, pixelHeight);\\n }\",\n \"private void sendResizeEventToFX() {\\n redraw();\\n update();\\n \\n pWidth = getClientArea().width;\\n pHeight = getClientArea().height;\\n\\n resizePixelBuffer(lastScaleFactor);\\n\\n if (scenePeer == null) {\\n return;\\n }\\n\\n stagePeer.setSize(pWidth, pHeight);\\n scenePeer.setSize(pWidth, pHeight);\\n }\",\n \"@objid (\\\"1b87bc2e-5e33-11e2-b81d-002564c97630\\\")\\n private Point getViewAreaSize() {\\n final Point controlSize = new Point(0, 0);\\n // this has to be done in the display thread to avoid\\n // InvalidThreadAccessException.\\n getViewer().getControl().getDisplay().syncExec(new Runnable() {\\n @Override\\n public void run() {\\n final Control control = BackgroundEditPart.this.getViewer().getControl();\\n Point p = control.getSize();\\n controlSize.x = p.x;\\n controlSize.y = p.y;\\n \\n if (control instanceof Scrollable) {\\n Scrollable c = (Scrollable) control;\\n ScrollBar b = c.getHorizontalBar();\\n if (b != null /* && b.isVisible() */) {\\n controlSize.y -= b.getSize().y;\\n }\\n b = c.getVerticalBar();\\n if (b != null /* && b.isVisible() */) {\\n controlSize.x -= b.getSize().x;\\n }\\n }\\n }\\n });\\n return controlSize;\\n }\",\n \"public void updateBoundaries() {\\n\\t\\t\\n\\t\\tLOG.log(\\\"Updating boundaries.\\\");\\n\\t\\t\\n\\t\\tif (Program.WINDOW_MANAGER != null) {\\n\\t\\t\\t\\n\\t\\t\\tthis.setBounds(\\n\\t\\t\\t\\tProgram.WINDOW_MANAGER.getScreenWidth() / 2 - this.getSize().width / 2,\\n\\t\\t\\t\\tProgram.WINDOW_MANAGER.getScreenHeight() / 2 - this.getSize().height / 2,\\n\\t\\t\\t\\tBOUNDS_LENGTH,\\n\\t\\t\\t\\tBOUNDS_WIDTH\\n\\t\\t\\t);\\n\\t\\t\\tthis.setLocationRelativeTo(null);\\n\\t\\t\\t\\n\\t\\t} else {\\n\\t\\t\\tthis.setBounds(10, 10, BOUNDS_LENGTH, BOUNDS_WIDTH);\\n\\t\\t}\\n\\t}\",\n \"private void transformObject(int x, int y) {\\n double sx, sy, l, r, nx, ny, tx, ty, alpha, origCX = 0, origCY = 0;\\n Rectangle bnds;\\n\\n if(curr_obj == transformPointers[Action.ROTATE]) {\\n /* the mouse vector 1 */\\n GeoVector mouseVector = new GeoVector(x, y, this.aux_obj.getCenterX(), this.aux_obj.getCenterY());\\n\\n /* the rotation vector. i.e. the fixed vector that will be used as origin composed by the subtraction of the object center with the rotation point */\\n GeoVector rotationVector = new GeoVector(this.lastPosition[0], this.lastPosition[1], this.aux_obj.getCenterX(), this.aux_obj.getCenterY());\\n\\n mouseVector.normalize();\\n rotationVector.normalize();\\n\\n alpha = mouseVector.getAngleWith(rotationVector.getX(), rotationVector.getY());\\n\\n /** After passing the 180 degrees, the atan2 function returns a negative angle from 0 to PI. So this will convert the final gobal angle to 0-2PI */\\n if(alpha < 0 ) {\\n alpha = (2 * Math.PI) + alpha; \\n }\\n\\n alpha -= this.currRotation;\\n this.currRotation += alpha;\\n\\n Point c = new Point(this.aux_obj.getCenterX(), this.aux_obj.getCenterY());\\n this.aux_obj.uRotate((float)(-1.0*(alpha*(180/Math.PI))), c);\\n \\n } else {\\n alpha = this.aux_obj.getRotation();\\n\\n /** Here we rotate the selected Graphic Object, it's tranformation points and the mouse coordinates back to the zero angle, to permit a correct object scalling. */\\n if(alpha != 0.0) {\\n origCX = this.aux_obj.getCenterX();\\n origCY = this.aux_obj.getCenterY();\\n this.aux_obj.uRotate((float)(alpha*-1.0), this.aux_obj.getCenter());\\n rotateTransformPoints(alpha);\\n GeoVector mouseCoord = new GeoVector(x, y, this.aux_obj.getCenterX(), this.aux_obj.getCenterY());\\n\\n mouseCoord.rotate( ((alpha*-1.0) * (2.0*Math.PI))/360 );\\n mouseCoord.addPoint(this.aux_obj.getCenterX(), this.aux_obj.getCenterY());\\n x = (int)mouseCoord.getX();\\n y = (int)mouseCoord.getY();\\n\\n }\\n\\n /** Tatami rotates the object from it's x and y point to the edges. So this means that sometimes we need to translate the object a few pixels to asure that it's upper left corner is on the same position. */\\n if(curr_obj == transformPointers[Action.NORTHWEST]) {\\n if(x < (transformPointers[Action.EAST].getX()-2) && y < (transformPointers[Action.SOUTH].getY()-2)) {\\n l = aux_obj.getX() - (transformPointers[Action.WEST].getX()+2);\\n r = (transformPointers[Action.EAST].getX()+2) - aux_obj.getX();\\n nx = (transformPointers[Action.EAST].getX()+2) - x ;\\n sx = nx / (l+r);\\n tx = (sx*l-l) + (sx*r-r);\\n\\n l = aux_obj.getY() - (transformPointers[Action.NORTH].getY()+2);\\n r = (transformPointers[Action.SOUTH].getY()+2) - aux_obj.getY();\\n ny = (transformPointers[Action.SOUTH].getY()+2) - y;\\n sy = ny / (l+r);\\n ty = (sy*l-l) + (sy*r-r);\\n\\n aux_obj.uTranslate((int)-tx, (int)-ty);\\n aux_obj.scale( (float)sx, (float)sy);\\n\\n if(alpha != 0.0) {\\n this.aux_obj.uTranslate((int)(origCX - this.aux_obj.getCenterX()), (int)(origCY - this.aux_obj.getCenterY()));\\n this.aux_obj.rotate((float)alpha);\\n }\\n\\n canvas.remove(transformPoints);\\n transformPoints.clear();\\n bnds = aux_obj.getBounds();\\n createTransformPoints(bnds, aux_obj);\\n curr_obj = transformPointers[Action.NORTHWEST];\\n }\\n } else if(curr_obj == transformPointers[Action.NORTH]) {\\n if(y < (transformPointers[Action.SOUTH].getY()-2)) {\\n l = aux_obj.getY() - (transformPointers[Action.NORTH].getY()+2);\\n r = (transformPointers[Action.SOUTH].getY()+2) - aux_obj.getY();\\n ny = (transformPointers[Action.SOUTH].getY()+2) - y;\\n sy = ny / (l+r);\\n ty = (sy*l-l) + (sy*r-r);\\n\\n aux_obj.uTranslate(0, (int)-ty);\\n aux_obj.scale( 1, (float)sy);\\n\\n if(alpha != 0.0) {\\n this.aux_obj.uTranslate((int)(origCX - this.aux_obj.getCenterX()), (int)(origCY - this.aux_obj.getCenterY()));\\n this.aux_obj.rotate((float)alpha);\\n }\\n\\n canvas.remove(transformPoints);\\n transformPoints.clear();\\n bnds = aux_obj.getBounds();\\n createTransformPoints(bnds, aux_obj);\\n curr_obj = transformPointers[Action.NORTH];\\n }\\n } else if(curr_obj == transformPointers[Action.NORTHEAST]) {\\n if(x > (transformPointers[Action.WEST].getX()+2) && y < (transformPointers[Action.SOUTH].getY()-2)) {\\n l = aux_obj.getX() - (transformPointers[Action.WEST].getX()+2);\\n r = (transformPointers[Action.EAST].getX()+2) - aux_obj.getX();\\n nx = x - (transformPointers[Action.WEST].getX()+2);\\n sx = nx / (l+r);\\n tx = sx*l-l;\\n\\n l = aux_obj.getY() - (transformPointers[Action.NORTH].getY()+2);\\n r = (transformPointers[Action.SOUTH].getY()+2) - aux_obj.getY();\\n ny = (transformPointers[Action.SOUTH].getY()+2) - y;\\n sy = ny / (l+r);\\n ty = (sy*l-l) + (sy*r-r);\\n\\n aux_obj.uTranslate((int)tx, (int)-ty);\\n aux_obj.scale( (float)sx, (float)sy);\\n\\n if(alpha != 0.0) {\\n this.aux_obj.uTranslate((int)(origCX - this.aux_obj.getCenterX()), (int)(origCY - this.aux_obj.getCenterY()));\\n this.aux_obj.rotate((float)alpha);\\n }\\n\\n canvas.remove(transformPoints);\\n transformPoints.clear();\\n bnds = aux_obj.getBounds();\\n createTransformPoints(bnds, aux_obj);\\n curr_obj = transformPointers[Action.NORTHEAST];\\n }\\n\\n } else if(curr_obj == transformPointers[Action.WEST]) {\\n if(x < (transformPointers[Action.EAST].getX()-2) ) {\\n l = aux_obj.getX() - (transformPointers[Action.WEST].getX()+2);\\n r = (transformPointers[Action.EAST].getX()+2) - aux_obj.getX();\\n nx = (transformPointers[Action.EAST].getX()+2) - x ;\\n sx = nx / (l+r);\\n tx = (sx*l-l) + (sx*r-r);\\n\\n aux_obj.uTranslate((int)-tx, 0);\\n aux_obj.scale( (float)sx, 1);\\n\\n if(alpha != 0.0) {\\n this.aux_obj.uTranslate((int)(origCX - this.aux_obj.getCenterX()), (int)(origCY - this.aux_obj.getCenterY()));\\n this.aux_obj.rotate((float)alpha);\\n }\\n\\n canvas.remove(transformPoints);\\n transformPoints.clear();\\n\\n bnds = aux_obj.getBounds();\\n createTransformPoints(bnds, aux_obj);\\n curr_obj = transformPointers[Action.WEST];\\n }\\n } else if(curr_obj == transformPointers[Action.EAST]) {\\n if(x > (transformPointers[Action.WEST].getX()+2) ) {\\n l = aux_obj.getX() - (transformPointers[Action.WEST].getX()+2);\\n r = (transformPointers[Action.EAST].getX()+2) - aux_obj.getX();\\n nx = x - (transformPointers[Action.WEST].getX()+2);\\n sx = nx / (l+r);\\n tx = sx*l-l;\\n\\n aux_obj.uTranslate((int)tx, 0);\\n aux_obj.scale( (float)sx, (float)1);\\n\\n if(alpha != 0.0) {\\n this.aux_obj.uTranslate((int)(origCX - this.aux_obj.getCenterX()), (int)(origCY - this.aux_obj.getCenterY()));\\n this.aux_obj.rotate((float)alpha);\\n }\\n\\n canvas.remove(transformPoints);\\n transformPoints.clear();\\n bnds = aux_obj.getBounds();\\n createTransformPoints(bnds, aux_obj);\\n curr_obj = transformPointers[Action.EAST];\\n }\\n } else if(curr_obj == transformPointers[Action.SOUTHWEST]) {\\n if(x < (transformPointers[Action.EAST].getX()-2) && y > (transformPointers[Action.NORTH].getY()+2)) {\\n l = aux_obj.getX() - (transformPointers[Action.WEST].getX()+2);\\n r = (transformPointers[Action.EAST].getX()+2) - aux_obj.getX();\\n nx = (transformPointers[Action.EAST].getX()+2) - x ;\\n sx = nx / (l+r);\\n tx = (sx*l-l) + (sx*r-r);\\n\\n l = aux_obj.getY() - (transformPointers[Action.NORTH].getY()+2);\\n r = (transformPointers[Action.SOUTH].getY()+2) - aux_obj.getY();\\n ny = y - (transformPointers[Action.NORTH].getY()+2);\\n sy = ny / (l+r);\\n ty = sy*l-l;\\n\\n aux_obj.uTranslate((int)-tx, (int)ty);\\n aux_obj.scale( (float)sx, (float)sy);\\n\\n if(alpha != 0.0) {\\n this.aux_obj.uTranslate((int)(origCX - this.aux_obj.getCenterX()), (int)(origCY - this.aux_obj.getCenterY()));\\n this.aux_obj.rotate((float)alpha);\\n }\\n\\n canvas.remove(transformPoints);\\n transformPoints.clear();\\n bnds = aux_obj.getBounds();\\n createTransformPoints(bnds, aux_obj);\\n curr_obj = transformPointers[Action.SOUTHWEST];\\n }\\n } else if(curr_obj == transformPointers[Action.SOUTH]) {\\n if(y > (transformPointers[Action.NORTH].getY()+2)) {\\n l = aux_obj.getY() - (transformPointers[Action.NORTH].getY()+2);\\n r = (transformPointers[Action.SOUTH].getY()+2) - aux_obj.getY();\\n ny = y - (transformPointers[Action.NORTH].getY()+2);\\n sy = ny / (l+r);\\n ty = sy*l-l;\\n\\n aux_obj.uTranslate(0, (int)ty);\\n aux_obj.scale( 1, (float)sy);\\n\\n if(alpha != 0.0) {\\n this.aux_obj.uTranslate((int)(origCX - this.aux_obj.getCenterX()), (int)(origCY - this.aux_obj.getCenterY()));\\n this.aux_obj.rotate((float)alpha);\\n }\\n\\n canvas.remove(transformPoints);\\n transformPoints.clear();\\n bnds = aux_obj.getBounds();\\n createTransformPoints(bnds, aux_obj);\\n curr_obj = transformPointers[Action.SOUTH];\\n }\\n } else if(curr_obj == transformPointers[Action.SOUTHEAST]) {\\n if(x > (transformPointers[Action.WEST].getX()+2) && y > (transformPointers[Action.NORTH].getY()+2)) {\\n\\n l = aux_obj.getX() - (transformPointers[Action.WEST].getX()+2);\\n r = (transformPointers[Action.EAST].getX()+2) - aux_obj.getX();\\n nx = x - (transformPointers[Action.WEST].getX()+2);\\n sx = nx / (l+r);\\n tx = sx*l-l;\\n\\n l = aux_obj.getY() - (transformPointers[Action.NORTH].getY()+2);\\n r = (transformPointers[Action.SOUTH].getY()+2) - aux_obj.getY();\\n ny = y - (transformPointers[Action.NORTH].getY()+2);\\n sy = ny / (l+r);\\n ty = sy*l-l;\\n\\n aux_obj.uTranslate((int)tx, (int)ty);\\n aux_obj.scale( (float)sx, (float)sy);\\n\\n if(alpha != 0.0) {\\n this.aux_obj.uTranslate((int)(origCX - this.aux_obj.getCenterX()), (int)(origCY - this.aux_obj.getCenterY()));\\n this.aux_obj.rotate((float)alpha);\\n }\\n\\n canvas.remove(transformPoints);\\n transformPoints.clear();\\n bnds = aux_obj.getBounds();\\n createTransformPoints(bnds, aux_obj);\\n curr_obj = transformPointers[Action.SOUTHEAST];\\n }\\n }\\n\\n\\n }\\n \\n }\",\n \"private void updateBoundingBox()\\n\\t{\\n\\t\\tif (this.facingDirection != null)\\n\\t\\t{\\n\\t\\t\\tdouble d0 = (double) this.hangingPosition.getX() + 0.5D;\\n\\t\\t\\tdouble d1 = (double) this.hangingPosition.getY() + 0.5D;\\n\\t\\t\\tdouble d2 = (double) this.hangingPosition.getZ() + 0.5D;\\n\\t\\t\\tdouble d3 = 0.46875D;\\n\\t\\t\\tdouble d4 = this.someFunc(this.getWidthPixels());\\n\\t\\t\\tdouble d5 = this.someFunc(this.getHeightPixels());\\n\\t\\t\\td0 = d0 - (double) this.facingDirection.getFrontOffsetX() * 0.46875D;\\n\\t\\t\\td2 = d2 - (double) this.facingDirection.getFrontOffsetZ() * 0.46875D;\\n\\t\\t\\td1 = d1 + d5;\\n\\t\\t\\tEnumFacing enumfacing = this.facingDirection.rotateYCCW();\\n\\t\\t\\td0 = d0 + d4 * (double) enumfacing.getFrontOffsetX();\\n\\t\\t\\td2 = d2 + d4 * (double) enumfacing.getFrontOffsetZ();\\n\\t\\t\\tthis.posX = d0;\\n\\t\\t\\tthis.posY = d1;\\n\\t\\t\\tthis.posZ = d2;\\n\\t\\t\\tdouble d6 = (double) this.getWidthPixels();\\n\\t\\t\\tdouble d7 = (double) this.getHeightPixels();\\n\\t\\t\\tdouble d8 = (double) this.getWidthPixels();\\n\\n\\t\\t\\tif (this.facingDirection.getAxis() == EnumFacing.Axis.Z)\\n\\t\\t\\t{\\n\\t\\t\\t\\td8 = 1.0D;\\n\\t\\t\\t}\\n\\t\\t\\telse\\n\\t\\t\\t{\\n\\t\\t\\t\\td6 = 1.0D;\\n\\t\\t\\t}\\n\\n\\t\\t\\t// ???\\n\\n\\t\\t\\td6 = d6 / (this.getWidthPixels() / this.blocksToTakeUp() * 2D);\\n\\t\\t\\td7 = d7 / (this.getHeightPixels() / this.blocksToTakeUp() * 2D);\\n\\t\\t\\td8 = d8 / (this.getWidthPixels() / this.blocksToTakeUp() * 2D);\\n\\t\\t\\tthis.setEntityBoundingBox(new AxisAlignedBB(d0 - d6, d1 - d7, d2 - d8, d0 + d6, d1 + d7, d2 + d8));\\n\\t\\t}\\n\\t}\",\n \"public void centreModel(){\\n\\t\\tcentreModel(modOffset);\\n\\t}\",\n \"public void normalizeCoordinates2D(Agent agent)\\n {\\n if (agent.x() < 0.5)\\n {\\n agent.getKinematic().setX(this.getWidth() - 0.5);\\n }\\n else if (agent.x() > this.getWidth() - 0.5)\\n {\\n agent.getKinematic().setX(0.5);\\n }\\n\\n if (agent.y() < 0.5)\\n {\\n agent.getKinematic().setY(this.getHeight() - 0.5);\\n }\\n else if (agent.y() > this.getHeight() - 0.5)\\n {\\n agent.getKinematic().setY(0.5);\\n }\\n }\",\n \"public void resize() {\\n\\t\\tsp.doLayout();\\n\\t}\",\n \"private void updateDimensions() {\\r\\n width = gui.getWidth();\\r\\n height = gui.getHeight();\\r\\n yLabelsMargin = (int) gui.getLabelWidth(Integer.toString(((int) maximumDB / 10) * 10), true) + 2;\\r\\n if (track != null)\\r\\n scaleXpx = ((float) width - yLabelsMargin) / track.getBufferCapacity();\\r\\n else\\r\\n scaleXpx = 1;\\r\\n scaleYpx = (float) ((height - 1) / (maximumDB - minimumDB));\\r\\n if (scaleYpx == 0)\\r\\n scaleYpx = 1;\\r\\n }\",\n \"private void geometry()\\n\\t\\t{\\n\\t\\tgridLayout = new GridLayout(2, -1);\\n\\n\\t\\tthis.setLayout(gridLayout);\\n\\n\\t\\tadd(component1);\\n\\t\\tadd(component2);\\n\\t\\t}\",\n \"public void onUpdate()\\n\\t{\\n\\t\\tchunk.setModelBound(new BoundingBox());\\n\\t\\tchunk.updateModelBound();\\n\\n\\t}\",\n \"@Override\\r\\n public void reshape(GLAutoDrawable drawable, int x, int y, int width, int height) {\\n GL2 gl = drawable.getGL().getGL2();\\r\\n\\r\\n //evita a divisão por zero\\r\\n if (height == 0) {\\r\\n height = 1;\\r\\n }\\r\\n //calcula a proporção da janela (aspect ratio) da nova janela\\r\\n float aspect = (float) width / height;\\r\\n\\r\\n //seta o viewport para abranger a janela inteira\\r\\n gl.glViewport(0, 0, width, height);\\r\\n\\r\\n //ativa a matriz de projeção\\r\\n gl.glMatrixMode(GL2.GL_PROJECTION);\\r\\n gl.glLoadIdentity(); //lê a matriz identidade\\r\\n\\r\\n //Projeção ortogonal\\r\\n //true: aspect >= 1 configura a altura de -1 para 1 : com largura maior\\r\\n //false: aspect < 1 configura a largura de -1 para 1 : com altura maior\\r\\n if (width >= height) {\\r\\n gl.glOrtho(xMin * aspect, xMax * aspect, yMin, yMax, zMin, zMax);\\r\\n } else {\\r\\n gl.glOrtho(xMin, xMax, yMin / aspect, yMax / aspect, zMin, zMax);\\r\\n }\\r\\n\\r\\n //ativa a matriz de modelagem\\r\\n gl.glMatrixMode(GL2.GL_MODELVIEW);\\r\\n gl.glLoadIdentity(); //lê a matriz identidade\\r\\n System.out.println(\\\"Reshape: \\\" + width + \\\", \\\" + height);\\r\\n }\",\n \"public void setMovingBounds() {\\r\\n maxY = this.getParent().getYmax();\\r\\n minY = this.getParent().getYmin();\\r\\n maxX = this.getParent().getXmax();\\r\\n minX = this.getParent().getXmin();\\r\\n }\",\n \"public void adjustSize() {\\r\\n /*\\r\\n * Calculate target width: max of header, adjusted window, content\\r\\n * \\r\\n * TODO: restrict to available desktop space\\r\\n */\\r\\n int targetWidth = TOTAL_BORDER_THICKNESS\\r\\n + MathUtils.maxInt(headerBar.getOffsetWidth(),\\r\\n contentWidget.getOffsetWidth(), getWidth()\\r\\n - TOTAL_BORDER_THICKNESS);\\r\\n /*\\r\\n * Calculate target height: max of adjusted window, content\\r\\n * \\r\\n * TODO: restrict to available desktop space\\r\\n */\\r\\n int targetHeight = TOTAL_BORDER_THICKNESS\\r\\n + MathUtils.maxInt(contentWidget.getOffsetHeight(), getHeight()\\r\\n - TOTAL_BORDER_THICKNESS - headerBar.getOffsetHeight());\\r\\n\\r\\n setPixelSize(targetWidth, targetHeight);\\r\\n }\",\n \"public abstract Transformation updateTransform(Rectangle selectionBox);\",\n \"public void onSizeChanged(int w, int h, int oldw, int oldh) {\\r\\n super.onSizeChanged(w, h, oldw, oldh);\\r\\n returnDefualt();\\r\\n this.startWidth = (float)getWidth()/4;\\r\\n this.endWidth = (float)getWidth()-((float)getWidth()/4);\\r\\n this.startHeight = (float)getHeight()/12;\\r\\n this.endHeight = getHeight()-((float)getHeight()/12);\\r\\n this.oval = new RectF(this.startWidth,this.startHeight , this.endWidth, this.endHeight);\\r\\n }\",\n \"@Override\\n protected void buildWorldRepresentation() {\\n java.util.List worldModelEntityList = spaceExplorerModel.getWorldEntityList();\\n java.util.List viewWorldEntityList = new ArrayList();\\n for (int i = 0; i < worldModelEntityList.size(); i++) {\\n\\n BasicModelEntity basicModelEntity = worldModelEntityList.get(i);\\n\\n CSysEntity cSysEntity = null;\\n if (basicModelEntity instanceof ModelLineEntity) {\\n cSysEntity = new SeCSysLineEntity(this, (ModelLineEntity) basicModelEntity);\\n cSysEntity.setDrawColor(basicModelEntity.getColor());\\n// addWorldEntity(cSysLineEntity);\\n } else if (basicModelEntity instanceof ModelPolyLineEntity) {\\n cSysEntity = new SeCSysViewPolyLineEntity(this, (ModelPolyLineEntity) basicModelEntity);\\n cSysEntity.setDrawColor(basicModelEntity.getColor());\\n// addWorldEntity(seCSysViewPolylineEntity);\\n }\\n viewWorldEntityList.add(cSysEntity);\\n }\\n\\n createAxis(viewWorldEntityList);\\n viewWorldEntityArray = viewWorldEntityList.toArray(new BasicCSysEntity[viewWorldEntityList.size()]);\\n updateCSysEntList(combinedRotatingMatrix);\\n }\",\n \"private void centre() {\\n Dimension localDimension = Toolkit.getDefaultToolkit().getScreenSize();\\n int i2 = (int) Math.min(localDimension.width * WIDTH, localDimension.height * WIDTH);\\n\\n Rectangle localRectangle = new Rectangle();\\n localRectangle.setBounds(((localDimension.width - i2) / TWO), \\n ((localDimension.height - i2) / TWO), i2, i2);\\n\\n setBounds(localRectangle);\\n\\n }\",\n \"void resetRoundHitbox() {\\n setRoundHitbox((_w+_h)/4);\\n }\",\n \"@Override\\n public void resize()\\n {\\n if (this.resizer != null)\\n {\\n this.resizer.apply(this.area);\\n }\\n\\n if (this.children != null)\\n {\\n this.children.resize();\\n }\\n\\n if (this.resizer != null)\\n {\\n this.resizer.postApply(this.area);\\n }\\n }\",\n \"public void updateBounds() {\\n\\t\\tswitch (this.species){\\n\\t\\tcase HOGCHOKER:\\n\\t\\tcase SILVERSIDE:\\n\\t\\tcase FLOUNDER:\\n\\t\\t\\tthis.topYBound = frameHeight / 3 * 2;\\n\\t\\t\\tthis.bottomYBound = frameHeight - imageHeight - frameBarSize;\\n\\t\\t\\tbreak;\\n\\t\\tcase PERCH: \\n\\t\\tcase MINNOW: \\n\\t\\tcase WEAKFISH:\\n\\t\\t\\tthis.topYBound = frameHeight / 3;\\n\\t\\t\\tthis.bottomYBound = frameHeight / 3 * 2 - imageHeight;\\n\\t\\t\\tbreak;\\n\\n\\t\\tcase MENHADEN:\\n\\t\\tcase MUMMICHOG:\\n\\t\\t\\tthis.topYBound = 0;\\n\\t\\t\\tthis.bottomYBound = frameHeight / 3 - imageHeight;\\n\\t\\t\\tbreak;\\n\\t\\tcase GOLD:\\n\\t\\tdefault:\\n\\t\\t\\ttopYBound = 0;\\n\\t\\t\\tbottomYBound = frameHeight;\\n\\t\\t}\\n\\t}\",\n \"@Override\\n\\tpublic BoundaryRectangle getBoundingBox() {\\n\\t\\treturn new BoundaryRectangle(0, 0, drawView.getWidth(), drawView.getHeight());\\n\\t}\",\n \"private void setDimensions() {\\n IPhysicalVolume physVol_parent = getModule().getGeometry().getPhysicalVolume();\\n ILogicalVolume logVol_parent = physVol_parent.getLogicalVolume();\\n ISolid solid_parent = logVol_parent.getSolid();\\n Box box_parent;\\n if (Box.class.isInstance(solid_parent)) {\\n box_parent = (Box) solid_parent;\\n } else {\\n throw new RuntimeException(\\\"Couldn't cast the module volume to a box!?\\\");\\n }\\n _length = box_parent.getXHalfLength() * 2.0;\\n _width = box_parent.getYHalfLength() * 2.0;\\n\\n }\",\n \"private void setGeometry() {\\n this.setCullHint(Spatial.CullHint.Dynamic);\\n this.setLocalTranslation(realPosition);\\n //attach geometry to this object\\n // mat.setColor(\\\"Color\\\", colors[r.nextInt(colors.length)]);\\n if (!companyTextures.containsKey(this.company)) {\\n mat.setTexture(\\\"ColorMap\\\", Colors.get(r.nextInt(Colors.size())));\\n } else {\\n mat.setTexture(\\\"ColorMap\\\", companyTextures.get(this.company));\\n }\\n geom.setMaterial(mat);\\n this.attachChild(geom.clone());\\n }\",\n \"protected Rectangle determineBounds() {\\n return getNetTransform().createTransformedShape( _bounds ).getBounds();\\n }\",\n \"public Rectangle getPlotBounds();\",\n \"@Override\\n\\tpublic void renderGeometry(SvgRenderContext state) {\\n\\t\\t\\n\\t}\",\n \"public void componentResized(ComponentEvent event) {\\n // first, size the lights and corners\\n double width = (double)getWidth() / ((double)maxHorizontalLights + 2); //< +2 for the corners!\\n double height = (double)getHeight() / ((double)maxVerticalLights + 2); //< +2 for the corners!\\n Dimension lightDimension = new Dimension((int)Math.round(width), (int)Math.round(height));\\n \\n // now set the locations and sizes of each light\\n // top border location\\n double x = width;\\n double y = 0;\\n for (int i = 0; i < topBorder.size(); i++) {\\n topBorder.get(i).setPosition(x, y);\\n topBorder.get(i).setPreferredSize(lightDimension);\\n topBorder.get(i).setSize(lightDimension);\\n x += width;\\n }\\n \\n // bottom border locations\\n x = width;\\n y = getHeight() - height;\\n for (int i = 0; i < bottomBorder.size(); i++) {\\n bottomBorder.get(i).setPosition(x, y);\\n bottomBorder.get(i).setPreferredSize(lightDimension);\\n bottomBorder.get(i).setSize(lightDimension);\\n x += width;\\n }\\n bottomRight.setPosition(x, y);\\n \\n // left border locations\\n x = 0;\\n y = height;\\n for (int i = 0; i < leftBorder.size(); i++) {\\n leftBorder.get(i).setPosition(x, y);\\n leftBorder.get(i).setPreferredSize(lightDimension);\\n leftBorder.get(i).setSize(lightDimension);\\n y += height;\\n }\\n \\n // right border\\n x = getWidth() - width;\\n y = height;\\n for (int i = 0; i < rightBorder.size(); i++) {\\n rightBorder.get(i).setPosition(x, y);\\n rightBorder.get(i).setPreferredSize(lightDimension);\\n rightBorder.get(i).setSize(lightDimension);\\n y += height;\\n }\\n \\n // set the size and locations of the corners\\n x = 0;\\n y = 0;\\n topLeft.setPosition(x, y);\\n topLeft.setPreferredSize(lightDimension);\\n topLeft.setSize(lightDimension);\\n x = getWidth() - width;\\n y = 0;\\n topRight.setPosition(x, y);\\n topRight.setPreferredSize(lightDimension);\\n topRight.setSize(lightDimension);\\n x = 0;\\n y = getHeight() - height;\\n bottomLeft.setPosition(x, y);\\n bottomLeft.setPreferredSize(lightDimension);\\n bottomLeft.setSize(lightDimension);\\n x = getWidth() - width;\\n y = getHeight() - height;\\n bottomRight.setPosition(x, y);\\n bottomRight.setPreferredSize(lightDimension);\\n bottomRight.setSize(lightDimension);\\n \\n // set the location and size of the tumbler display\\n width = getWidth() - (2 * width);\\n height = getHeight() - (2 * height);\\n Dimension tumblerDisplayDimension = new Dimension((int)Math.round(width), (int)Math.round(height));\\n tumblerDisplay.setPreferredSize(tumblerDisplayDimension);\\n tumblerDisplay.setSize(tumblerDisplayDimension);\\n tumblerDisplay.setLocation(topLeft.getWidth(), topLeft.getHeight());\\n }\",\n \"protected void layoutImpl()\\n {\\n // Set chart area height first, since height can effect yaxis label width\\n double pw = getWidth(), ph = getHeight();\\n double ah = _xaxis.isVisible()? _xaxis.getPrefHeight() : 0;\\n _chartArea.setHeight(ph - ah);\\n \\n // Now set bounds of areay, xaxis and yaxis\\n double aw = _yaxis.isVisible()? _yaxis.getPrefWidth(ph - ah) : 0;\\n double cw = pw - aw, ch = ph - ah;\\n _chartArea.setBounds(aw,0,cw,ch);\\n _xaxis.setBounds(aw,ch,cw,ah);\\n _yaxis.setBounds(0,0,aw,ch);\\n }\",\n \"private void destroyBounds() {\\n size -= 4;\\n this.setBounds(bounds.left, bounds.top);\\n if (size <= 0) models.remove(this);\\n }\",\n \"@Override\\n public void onSizeChanged(int w, int h, int oldW, int oldH) {\\n // Set the movement bounds for the ball\\n displayArea.setDisp(w-1, h-1);\\n if (!isInitBackground) {\\n isInitBackground = true;\\n backgCalculating = new BackCalculating(0, 0, displayArea.xMax, displayArea.yMax, Color.BLACK, Color.YELLOW);\\n }\\n }\",\n \"@Override\\n public void componentResized(ComponentEvent arg0) {\\n width = jframe.getSize().getWidth();\\n height = jframe.getSize().getHeight();\\n baseBallCard.setLocation(0, (int) height - 175);\\n gearbutton.setLocation((int) width - 79, (int) height - 99);\\n settingspanel.setSize(new Dimension((int) (.6 * width), (int) (.6 * height)));\\n settingspanel.setLocation((int) (.2 * width), (int) (.15 * height));\\n int sx = (int) (.6 * width);\\n int sy = (int) (.6 * height);\\n storyPanel.setSize(new Dimension((int) (.6 * width), (int) (.6 * height)));\\n storyPanel.setLocation((int) (.2 * width), (int) (.15 * height));\\n storyPanel.setBackground(new Color(.8f, .8f, 1f, .75f));\\n story.setSize(new Dimension(storyPanel.getWidth()-50, storyPanel.getHeight()-50));\\n story.setBackground(new Color(.8f, .8f, 1f, .75f));\\n story.setLocation(25,25);\\n sphereSize.setSize((int) (.3 * sx), 20);\\n bgColor.setSize((int) (.3 * sx), 20);\\n sphereSize.setLocation((int) (.1 * sx), (int) (.25 * sy));\\n bgColor.setLocation((int) (.1 * sx), (int) (.35 * sy));\\n bgtext.setLocation((int) (.5 * sx), (int) (.35 * sy));\\n sphsi.setLocation((int) (.5 * sx), (int) (.25 * sy));\\n showall.setLocation((int) (.5 * sx), (int) (.8 * sy));\\n points.setLocation((int) (.175 * sx), (int) (.7 * sy));\\n debug.setLocation((int) (.175 * sx), (int) (.8 * sy));\\n wireframe.setLocation((int) (.175 * sx), (int) (.9 * sy));\\n close.setLocation(sx - 30, sy - (sy - 10));\\n aboutpanel.setSize(new Dimension(461, 347));\\n aboutpanel.setLocation((int) (.3 * width), (int) (.3 * height));\\n aboutpanel.add(aboutclose);\\n aboutclose.setLocation(440, 10);\\n resetrestrictions.setLocation((int) (.025 * sx), 25);\\n glcanvas.requestFocusInWindow();\\n }\",\n \"@Override\\r\\n\\t\\tpublic void update(Rectangle2D r) {\\r\\n\\t\\t\\t\\r\\n\\t\\t\\tmakeDirty(r, false);\\r\\n\\t\\t\\tif (_clipping != null) \\r\\n\\t\\t\\t\\trepaint(_clipping.getTransform().createTransformedShape(r).getBounds());\\r\\n\\t\\t}\",\n \"public RMRect getFrame() { return isRSS()? convertRectToShape(getBoundsInside(), _parent) : getBounds(); }\",\n \"private void expandDirtyRect(float historicalX, float historicalY) {\\n if (historicalX < mDirtyRect.left) {\\n mDirtyRect.left = historicalX;\\n } else if (historicalX > mDirtyRect.right) {\\n mDirtyRect.right = historicalX;\\n }\\n if (historicalY < mDirtyRect.top) {\\n mDirtyRect.top = historicalY;\\n } else if (historicalY > mDirtyRect.bottom) {\\n mDirtyRect.bottom = historicalY;\\n }\\n }\",\n \"public void computeSRectangleBound()\\n {\\n this.savedSRectangleBound = getSRectangleBound();\\n }\",\n \"private void updateBoundary() {\\n //pos = _newPos ;\\n heading = myRoute.getCurrentHeading() ;\\n //System.out.println(\\\"heading=\\\"+heading);\\n Point vertex = new Point(0,0) ;\\n vertex.x = length/2 ;\\n vertex.y = width/2 ;\\n boundary[0] = transform(vertex) ;\\n \\n vertex.x = -length/2 ;\\n vertex.y = width/2 ;\\n boundary[1] = transform(vertex) ;\\n \\n vertex.x = -length/2 ;\\n vertex.y = -width/2 ;\\n boundary[2] = transform(vertex) ;\\n \\n vertex.x = length/2 ;\\n vertex.y = -width/2 ;\\n boundary[3] = transform(vertex) ;\\n for (int i=0; i<4; i++) {\\n xpoints[i] = boundary[i].x ;\\n ypoints[i] = boundary[i].y ;\\n }\\n }\",\n \"private void recalculatePosition()\\n {\\n position.x = gridCoordinate.getCol()*(width+horizontal_spacing);\\n position.y = gridCoordinate.getRow()*(heigh+vertical_spacing);\\n }\",\n \"public void setGraphicalWidgetBounds(double tempOriginX,\\n double tempOriginY,\\n double tempWidth,\\n double tempHeight,\\n GraphicalWidget gw)\\n {\\n frameUI.setGraphicalWidgetBounds(tempOriginX,\\n tempOriginY,\\n tempWidth,\\n tempHeight,\\n gw);\\n }\",\n \"private void panelMouseReleased(java.awt.event.MouseEvent evt)\\n throws Exception {\\n\\n /*This is the release point*/\\n Point releasePoint = null;\\n\\n /*Check if something was selected and if the mouse was dragged*/\\n if ((selectedShape != null)&& (mouseIsDragged)) {\\n \\n /*Get the current release Point*/\\n releasePoint = evt.getPoint();\\n\\n /*Check if Shapes are within boundaries*/\\n if (this.selectedShape instanceof ShapeConcept) {\\n\\n /*Check if the ShapeConcept is inside the canvas area*/\\n offScreenShapeResize( ((ShapeConcept) selectedShape).getBounds());\\n }//end ShapeConcept\\n else if (this.selectedShape instanceof ShapeLinking) {\\n\\n /*Check if the ShapeConcept is inside the canvas area*/\\n offScreenShapeResize( ((ShapeLinking) selectedShape).getBounds());\\n }//end LinkingPhraze\\n else if (this.selectedShape instanceof ShapeComment) {\\n\\n /*Check if the ShapeConcept is inside the canvas area*/\\n offScreenShapeResize( ((ShapeComment) selectedShape).getBounds());\\n }//end ShapeComment\\n else if (this.selectedShape instanceof ShapeURL) {\\n\\n /*Check if the ShapeConcept is inside the canvas area*/\\n offScreenShapeResize( ((ShapeURL) selectedShape).getBounds());\\n }//end ShapeURL\\n }//end if\\n\\n /**When mouse is released, finish dragging just reset values**/\\n releasePoint = null;\\n mouseIsDragged = false;\\n //selectedShape = null;\\n repaint();\\n}\"\n]"},"negative_scores":{"kind":"list like","value":["0.61038756","0.5853969","0.56565","0.56296396","0.54492897","0.54189163","0.5397656","0.53879243","0.5357473","0.53415453","0.53393626","0.5327451","0.53194404","0.53066796","0.52869606","0.5266498","0.5236394","0.5231254","0.5230797","0.5214075","0.52020305","0.5189365","0.5186487","0.51777434","0.5161228","0.5160669","0.5142432","0.51148194","0.5112278","0.51108456","0.5106249","0.5098918","0.50944036","0.5076104","0.5076104","0.50573677","0.5052604","0.5047581","0.502895","0.5004526","0.5002307","0.5001043","0.49984282","0.4983798","0.49803928","0.49613196","0.49598837","0.49537396","0.4950039","0.49398547","0.49380648","0.49368146","0.49310163","0.49281386","0.49246138","0.49235088","0.49218485","0.49183768","0.4916848","0.49139997","0.49113685","0.49086076","0.49001858","0.48990306","0.48863947","0.48690322","0.48667634","0.48633122","0.48625728","0.48568764","0.48491815","0.4846777","0.48426434","0.48393714","0.48346397","0.4833387","0.482215","0.48167822","0.48165205","0.48141098","0.48137861","0.48065546","0.4804021","0.47919434","0.47899556","0.478826","0.47851866","0.47821203","0.47770977","0.47635442","0.4762751","0.47612417","0.47603726","0.4759991","0.47598508","0.4755794","0.47540924","0.47486988","0.47476777","0.47367367","0.473037"],"string":"[\n \"0.61038756\",\n \"0.5853969\",\n \"0.56565\",\n \"0.56296396\",\n \"0.54492897\",\n \"0.54189163\",\n \"0.5397656\",\n \"0.53879243\",\n \"0.5357473\",\n \"0.53415453\",\n \"0.53393626\",\n \"0.5327451\",\n \"0.53194404\",\n \"0.53066796\",\n \"0.52869606\",\n \"0.5266498\",\n \"0.5236394\",\n \"0.5231254\",\n \"0.5230797\",\n \"0.5214075\",\n \"0.52020305\",\n \"0.5189365\",\n \"0.5186487\",\n \"0.51777434\",\n \"0.5161228\",\n \"0.5160669\",\n \"0.5142432\",\n \"0.51148194\",\n \"0.5112278\",\n \"0.51108456\",\n \"0.5106249\",\n \"0.5098918\",\n \"0.50944036\",\n \"0.5076104\",\n \"0.5076104\",\n \"0.50573677\",\n \"0.5052604\",\n \"0.5047581\",\n \"0.502895\",\n \"0.5004526\",\n \"0.5002307\",\n \"0.5001043\",\n \"0.49984282\",\n \"0.4983798\",\n \"0.49803928\",\n \"0.49613196\",\n \"0.49598837\",\n \"0.49537396\",\n \"0.4950039\",\n \"0.49398547\",\n \"0.49380648\",\n \"0.49368146\",\n \"0.49310163\",\n \"0.49281386\",\n \"0.49246138\",\n \"0.49235088\",\n \"0.49218485\",\n \"0.49183768\",\n \"0.4916848\",\n \"0.49139997\",\n \"0.49113685\",\n \"0.49086076\",\n \"0.49001858\",\n \"0.48990306\",\n \"0.48863947\",\n \"0.48690322\",\n \"0.48667634\",\n \"0.48633122\",\n \"0.48625728\",\n \"0.48568764\",\n \"0.48491815\",\n \"0.4846777\",\n \"0.48426434\",\n \"0.48393714\",\n \"0.48346397\",\n \"0.4833387\",\n \"0.482215\",\n \"0.48167822\",\n \"0.48165205\",\n \"0.48141098\",\n \"0.48137861\",\n \"0.48065546\",\n \"0.4804021\",\n \"0.47919434\",\n \"0.47899556\",\n \"0.478826\",\n \"0.47851866\",\n \"0.47821203\",\n \"0.47770977\",\n \"0.47635442\",\n \"0.4762751\",\n \"0.47612417\",\n \"0.47603726\",\n \"0.4759991\",\n \"0.47598508\",\n \"0.4755794\",\n \"0.47540924\",\n \"0.47486988\",\n \"0.47476777\",\n \"0.47367367\",\n \"0.473037\"\n]"},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":4695,"cells":{"query":{"kind":"string","value":"Returns a list of the vertices for the mesh's arbitrarily orientated bounding box (AOBB)"},"document":{"kind":"string","value":"public Vector[] getBoxVerts() {\n\t\treturn boxVerts;\n\t}"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["public static String bboxVertices(){\n \treturn \"0.5 0.5 0.5 0.5 0.5 -0.5 0.5 -0.5 0.5 0.5 -0.5 -0.5 -0.5 0.5 0.5 -0.5 0.5 -0.5 -0.5 -0.5 0.5 -0.5 -0.5 -0.5\";\n }","private void calcBoxVerts() {\n\t\tif (verts != null) {\n\t\t\tdouble minX = verts[0].getElement(0);\n\t\t\tdouble maxX = minX;\n\t\t\tdouble minY = verts[0].getElement(1);\n\t\t\tdouble maxY = minY;\n\t\t\tdouble minZ = verts[0].getElement(2);\n\t\t\tdouble maxZ = minZ;\n\t\t\tfor (int i = 1; i < verts.length; i++) {\n\t\t\t\tif (verts[i].getElement(0) < minX) {\n\t\t\t\t\tminX = verts[i].getElement(0);\n\t\t\t\t} else if (verts[i].getElement(0) > maxX) {\n\t\t\t\t\tmaxX = verts[i].getElement(0);\n\t\t\t\t}\n\t\t\t\tif (verts[i].getElement(1) < minY) {\n\t\t\t\t\tminY = verts[i].getElement(1);\n\t\t\t\t} else if (verts[i].getElement(1) > maxY) {\n\t\t\t\t\tmaxY = verts[i].getElement(1);\n\t\t\t\t}\n\t\t\t\tif (verts[i].getElement(2) < minZ) {\n\t\t\t\t\tminZ = verts[i].getElement(2);\n\t\t\t\t} else if (verts[i].getElement(2) > maxZ) {\n\t\t\t\t\tmaxZ = verts[i].getElement(2);\n\t\t\t\t}\n\t\t\t}\n\t\t\tVector[] boxVerts = new Vector[8];\n\t\t\tboxVerts[0] = new Vector(3);\n\t\t\tboxVerts[0].setElements(new double[] {minX, minY, minZ});\n\t\t\tboxVerts[1] = new Vector(3);\n\t\t\tboxVerts[1].setElements(new double[] {maxX, minY, minZ});\n\t\t\tboxVerts[2] = new Vector(3);\n\t\t\tboxVerts[2].setElements(new double[] {minX, minY, maxZ});\n\t\t\tboxVerts[3] = new Vector(3);\n\t\t\tboxVerts[3].setElements(new double[] {maxX, minY, maxZ});\n\t\t\tboxVerts[4] = new Vector(3);\n\t\t\tboxVerts[4].setElements(new double[] {minX, maxY, minZ});\n\t\t\tboxVerts[5] = new Vector(3);\n\t\t\tboxVerts[5].setElements(new double[] {maxX, maxY, minZ});\n\t\t\tboxVerts[6] = new Vector(3);\n\t\t\tboxVerts[6].setElements(new double[] {minX, maxY, maxZ});\n\t\t\tboxVerts[7] = new Vector(3);\n\t\t\tboxVerts[7].setElements(new double[] {maxX, maxY, maxZ});\n\t\t\tthis.boxVerts = boxVerts;\n\t\t} else {\n\t\t\tthis.boxVerts = null;\n\t\t}\n\t}","public void constructBoundingBox()\r\n\t{\n\t\tdouble a = m_Qmin.x;\r\n\t\tdouble b = m_Qmin.y;\r\n\t\tdouble c = m_Qmin.z;\r\n\r\n\t\tdouble d = m_Qmax.x;\r\n\t\tdouble e = m_Qmax.y;\r\n\t\tdouble f = m_Qmax.z;\r\n\r\n\t\t//constructing the vertexes of the bounding box\r\n\t\tSceneVertex A = new SceneVertex( new Vector3d(a, b, c));\r\n\t\tSceneVertex B = new SceneVertex( new Vector3d(d, b, c));\r\n\t\tSceneVertex C = new SceneVertex( new Vector3d(d, b, f));\r\n\t\tSceneVertex D = new SceneVertex( new Vector3d(d, e, f));\r\n\t\tSceneVertex E = new SceneVertex( new Vector3d(a, e, f));\r\n\t\tSceneVertex F = new SceneVertex( new Vector3d(a, e, c));\r\n\t\tSceneVertex G = new SceneVertex( new Vector3d(d, e, c));\r\n\t\tSceneVertex H = new SceneVertex( new Vector3d(a, b, f));\r\n\r\n\r\n\t\t// building the vertices arrays for the faces\r\n\t\tArrayList verArrP0front = new ArrayList(4);\r\n\t\tverArrP0front.add(A);\r\n\t\tverArrP0front.add(B);\r\n\t\tverArrP0front.add(G);\r\n\t\tverArrP0front.add(F);\r\n\t\t\r\n\t\tArrayList verArrP1left = new ArrayList(4);\r\n\t\tverArrP1left.add(A);\r\n\t\tverArrP1left.add(F);\r\n\t\tverArrP1left.add(E);\r\n\t\tverArrP1left.add(H);\r\n\t\t\r\n\t\tArrayList verArrP2back = new ArrayList(4);\r\n\t\tverArrP2back.add(H);\r\n\t\tverArrP2back.add(C);\r\n\t\tverArrP2back.add(D);\r\n\t\tverArrP2back.add(E);\r\n\t\t\r\n\t\tArrayList verArrP3right = new ArrayList(4);\r\n\t\tverArrP3right.add(G);\r\n\t\tverArrP3right.add(D);\r\n\t\tverArrP3right.add(C);\r\n\t\tverArrP3right.add(B);\r\n\t\t\r\n\t\tArrayList verArrP4bottom = new ArrayList(4);\r\n\t\tverArrP4bottom.add(A);\r\n\t\tverArrP4bottom.add(H);\r\n\t\tverArrP4bottom.add(C);\r\n\t\tverArrP4bottom.add(B);\r\n\r\n\t\tArrayList verArrP5top = new ArrayList(4);\r\n\t\tverArrP5top.add(F);\r\n\t\tverArrP5top.add(G);\r\n\t\tverArrP5top.add(D);\r\n\t\tverArrP5top.add(E);\r\n\t\t\r\n\t\t// creating BoundingBox\r\n\t\tm_BoundingBox = new SceneNode(DrawingMode.GL_LINE, \"BoundingBox\", null);\r\n\t\tm_BoundingBox.addChild( new ScenePolygon(verArrP0front, \"FRONT\"));\r\n\t\tm_BoundingBox.addChild( new ScenePolygon(verArrP1left, \"LEFT\"));\r\n\t\tm_BoundingBox.addChild( new ScenePolygon(verArrP2back, \"BACK\"));\r\n\t\tm_BoundingBox.addChild( new ScenePolygon(verArrP3right, \"RIGHT\"));\r\n\t\tm_BoundingBox.addChild( new ScenePolygon(verArrP4bottom, \"BOTTOM\"));\r\n\t\tm_BoundingBox.addChild( new ScenePolygon(verArrP5top, \"TOP\"));\r\n\r\n\t\t\r\n\t}","public ArrayList getVertex(Block bl) {\r\n\t\tArrayList pivot = new ArrayList();\r\n\t\tpivot.add(bl.getpoint_BlockTopLeft());\r\n\t\tpivot.add(bl.getpoint_BlockTopRight());\r\n\t\tpivot.add(bl.getPoint_BlockDownRight());\r\n\t\tpivot.add(bl.getpoint_BlockDownleft());\r\n\t\treturn pivot;\r\n\t}","public java.util.List getVertices();","public abstract Vector2[] getVertices();","DAABBC getAABB ();","public float[] getVertices() {\n/* 793 */ COSBase base = getCOSObject().getDictionaryObject(COSName.VERTICES);\n/* 794 */ if (base instanceof COSArray)\n/* */ {\n/* 796 */ return ((COSArray)base).toFloatArray();\n/* */ }\n/* 798 */ return null;\n/* */ }","@Override\r\n\tpublic ArrayList getVertices() {\r\n\t\tArrayList verts = new ArrayList<>();\r\n\t\tvertices.forEach((E t, Vertex u) -> {\r\n\t\t\tverts.add(t);\r\n\t\t});\r\n\t\treturn verts;\r\n\t}","public E[] verticesView ()\n {\n E[] allVertices = (E[]) new Object[lastIndex + 1];\n for (int index = 0; index < allVertices.length; index++)\n allVertices[index] = this.vertices[index];\n\n return allVertices;\n }","List getVertexList();","int getVertices();","public Vector3f[] getVertices() {\n return vertices;\n }","public float[] getVertices() {\r\n\t\treturn vertices;\r\n\t}","public Collection getVertices();","private void generateBoxGeom()\n {\n // textures all share the same array, so process separately.\n textureBuffer = createBuffer(BOX_TEX_COORDS.length);\n textureBuffer.put(BOX_TEX_COORDS);\n textureBuffer.rewind();\n\n vertexBuffer = new FloatBuffer[6];\n normalBuffer = new FloatBuffer[6];\n\n for(int i = 0; i < 6; i++)\n {\n vertexBuffer[i] = createBuffer(12);\n normalBuffer[i] = createBuffer(12);\n }\n\n vertexBuffer[POSITIVE_X].put(RIGHT_BOX_COORDS);\n normalBuffer[POSITIVE_X].put(RIGHT_BOX_NORMALS);\n\n vertexBuffer[NEGATIVE_X].put(LEFT_BOX_COORDS);\n normalBuffer[NEGATIVE_X].put(LEFT_BOX_NORMALS);\n\n vertexBuffer[POSITIVE_Y].put(TOP_BOX_COORDS);\n normalBuffer[POSITIVE_Y].put(TOP_BOX_NORMALS);\n\n vertexBuffer[NEGATIVE_Y].put(BOTTOM_BOX_COORDS);\n normalBuffer[NEGATIVE_Y].put(BOTTOM_BOX_NORMALS);\n\n vertexBuffer[POSITIVE_Z].put(BACK_BOX_COORDS);\n normalBuffer[POSITIVE_Z].put(BACK_BOX_NORMALS);\n\n vertexBuffer[NEGATIVE_Z].put(FRONT_BOX_COORDS);\n normalBuffer[NEGATIVE_Z].put(FRONT_BOX_NORMALS);\n\n for(int i = 0; i < 6; i++)\n {\n vertexBuffer[i].rewind();\n normalBuffer[i].rewind();\n }\n }","Iterable vertices() {\n //YOUR CODE HERE, this currently returns only an empty list.\n return world.keySet();\n }","public Vertex[] getVertices() {\n return arrayOfVertices;\n }","public List getVertices(){\r\n return vertices;\r\n }","@Override\r\n\tpublic Vector2f[] getVertices() {\n\t\treturn null;\r\n\t}","public static float[] getMeshVertices(GVRMesh mesh) {\n GVRVertexBuffer vertexBuffer = mesh.getVertexBuffer();\n FloatBuffer floatBuffer = vertexBuffer.getFloatVec(\"a_position\");\n int count = floatBuffer.remaining();\n float[] vertices = new float[count];\n floatBuffer.get(vertices);\n // For 3.3 this still works\n// float[] vertices = mesh.getVertices(); // Throws UnsupportedOperationException in 4.0\n return vertices;\n }","godot.wire.Wire.AABB getAabbValue();","private Coordinate[] generateBoundingBox(final Geometry geometry) {\n if (geometry == null || geometry.getCoordinates() == null || geometry.getCoordinates().length == 0) {\n return new Coordinate[]{new Coordinate(0,0),new Coordinate(0,0)};\n }\n final Coordinate firstPoint = geometry.getCoordinates()[0];\n double minLat = firstPoint.y;\n double minLon = firstPoint.x;\n double maxLat = firstPoint.y;\n double maxLon = firstPoint.x;\n for (final Coordinate coordinate : geometry.getCoordinates()) {\n if (coordinate.x < minLon) {\n minLon = coordinate.x;\n }\n if (coordinate.y < minLat) {\n minLat = coordinate.y;\n }\n if (coordinate.x > maxLon) {\n maxLon = coordinate.x;\n }\n if (coordinate.y > maxLat) {\n maxLat = coordinate.y;\n }\n }\n return new Coordinate[]{\n new Coordinate(minLon, minLat),\n new Coordinate(maxLon, maxLat)\n };\n }","public Enumeration vertices();","public void computeBoundingBox() {\n\taveragePosition = new Point3(center);\n tMat.rightMultiply(averagePosition);\n \n minBound = new Point3(Double.POSITIVE_INFINITY, Double.POSITIVE_INFINITY, Double.POSITIVE_INFINITY);\n maxBound = new Point3(Double.POSITIVE_INFINITY, Double.POSITIVE_INFINITY, Double.POSITIVE_INFINITY);\n // Initialize\n Point3[] v = new Point3[8];\n for (int i = 0; i < 8; i++)\n \tv[i] = new Point3(center);\n // Vertices of the box\n v[0].add(new Vector3(-radius, -radius, -height/2.0));\n v[1].add(new Vector3(-radius, radius, -height/2.0));\n v[2].add(new Vector3(radius, -radius, -height/2.0));\n v[3].add(new Vector3(radius, radius, -height/2.0));\n v[4].add(new Vector3(-radius, -radius, height/2.0));\n v[5].add(new Vector3(-radius, radius, height/2.0));\n v[6].add(new Vector3(radius, -radius, height/2.0));\n v[7].add(new Vector3(radius, radius, height/2.0));\n // Update minBound and maxBound\n for (int i = 0; i < 8; i++)\n {\n \ttMat.rightMultiply(v[i]);\n \tif (v[i].x < minBound.x)\n \t\tminBound.x = v[i].x;\n \tif (v[i].x > maxBound.x)\n \t\tmaxBound.x = v[i].x;\n \tif (v[i].y < minBound.y)\n \t\tminBound.y = v[i].y;\n \tif (v[i].y > maxBound.y)\n \t\tmaxBound.y = v[i].y;\n \tif (v[i].z < minBound.z)\n \t\tminBound.z = v[i].z;\n \tif (v[i].z > maxBound.z)\n \t\tmaxBound.z = v[i].z;\n }\n \n }","public Vector[] getVerts() {\n\t\treturn this.verts;\n\t}","godot.wire.Wire.AABBOrBuilder getAabbValueOrBuilder();","public List vertices() {\n return Collections.unmodifiableList(this.vertices);\n }","public E3DVector3F getVertexPosB(){\r\n return vertices[1].getVertexPos();\r\n }","public int[] getVertices() {\n long cPtr = RecastJNI.rcContour_verts_get(swigCPtr, this);\n if (cPtr == 0) {\n return null;\n }\n return Converter.convertToInts(cPtr, getNumberOfVertices() * 4);\n }","private E3DTexturedVertex getVertexA(){\r\n\t\treturn vertices[0];\r\n\t}","public native Point [] getAllocationVertices(Actor ancestor);","private static native long createEdgeBoxes_0(float alpha, float beta, float eta, float minScore, int maxBoxes, float edgeMinMag, float edgeMergeThr, float clusterMinMag, float maxAspectRatio, float minBoxArea, float gamma, float kappa);","public Vertex[] getVertices() {\n\t\treturn this._vertices.toArray(new Vertex[0]);\n\t}","public ArrayList getOccluderVertexData();","public int[] getBoxes() { return boxes; }","protected Envelope[] getBoundingBoxes( Element element, CoordinateSystem defaultCoordinateSystem )\n throws XMLParsingException,\n InvalidParameterValueException {\n\n List boundingBoxList = XMLTools.getNodes( element, PRE_OWS + \"BoundingBox\", nsContext );\n\n List bboxesList = new ArrayList( boundingBoxList.size() );\n\n for ( int i = 0; i < boundingBoxList.size(); i++ ) {\n bboxesList.add( parseBoundingBox( (Element) boundingBoxList.get( i ), defaultCoordinateSystem ) );\n }\n\n // The ogc_wpvs schema says: wgs84 is mandatory therefore-> not checking parents to use it's\n // bboxes.\n\n // if ( parent != null ) {\n // Envelope[] boundingBoxes = parent.getBoundingBoxes();\n // for ( int i = 0; i < boundingBoxes.length; i++ ) {\n // bboxesList.add( boundingBoxes[i] );\n // }\n // }\n\n Envelope[] boxes = bboxesList.toArray( new Envelope[bboxesList.size()] );\n return boxes;\n }","public void calculateBoundsAABB() {\n\t\tsuper.minY = 0;\n\t\tradius = 0;\n\t\tmaxY = 0;\n\t\tminX = 999999;\n\t\tmaxX = -999999;\n\t\tmaxZ = -99999;\n\t\tminZ = 99999;\n\t\tfor (int j = 0; j < vertexCount; j++) {\n\t\t\tint x = vertexX[j];\n\t\t\tint y = vertexY[j];\n\t\t\tint z = vertexZ[j];\n\t\t\tif (x < minX) {\n\t\t\t\tminX = x;\n\t\t\t}\n\t\t\tif (x > maxX) {\n\t\t\t\tmaxX = x;\n\t\t\t}\n\t\t\tif (z < minZ) {\n\t\t\t\tminZ = z;\n\t\t\t}\n\t\t\tif (z > maxZ) {\n\t\t\t\tmaxZ = z;\n\t\t\t}\n\t\t\tif (-y > super.minY) {\n\t\t\t\tsuper.minY = -y;\n\t\t\t}\n\t\t\tif (y > maxY) {\n\t\t\t\tmaxY = y;\n\t\t\t}\n\t\t\tint radiusSqr = (x * x) + (z * z);\n\t\t\tif (radiusSqr > radius) {\n\t\t\t\tradius = radiusSqr;\n\t\t\t}\n\t\t}\n\t\tradius = (int) Math.sqrt(radius);\n\t\tminDepth = (int) Math.sqrt((radius * radius) + (super.minY * super.minY));\n\t\tmaxDepth = minDepth + (int) Math.sqrt((radius * radius) + (maxY * maxY));\n\t}","static void trial4() {\n ModelBuilder modelBuilder = new ModelBuilder();\n Model cubeModel = modelBuilder.createBox(\n 5f,\n 5f,\n 5f,\n new Material( ColorAttribute.createDiffuse(Color.GREEN) ),\n Usage.Position);\n Mesh cubeMesh = cubeModel.meshes.get(0);\n\n // There are 36 vertex indices\n // I take it this is because there are 2 triangle per face\n // 3 x 2 x 6 = 36\n System.err.println(cubeMesh.getNumIndices());\n\n short[] cubeIndices = new short[36];\n cubeMesh.getIndices(cubeIndices);\n for (int i = 0; i < 36; i+=3) {\n for (int j = 0; j <= 2; j++) {\n System.err.printf(\"%3d \", cubeIndices[i+j]);\n }\n System.err.println();\n }\n\n }","public IntPoint[] getVertices() {\n\t\treturn PointArrays.copy(vertices);\n\t}","public Set getVertices();","public Set getVertices();","public Collection vertices() {\n\t\tArrayList vertices = new ArrayList(this.segments.size());\n\t\t\n\t\t// iterate on segments, and add the control points of each segment\n\t\tfor (Segment seg : this.segments) {\n\t\t\tfor (GJPoint2D p : seg.controlPoints()) {\n\t\t\t\tvertices.add(p);\n\t\t\t}\n\t\t}\n\t\t\n\t\t// return the set of vertices\n\t\treturn vertices;\n\t}","public Vertice[] getSelectedVertices(){\n\t\tVertice selectedVertice;\n\t\tVertice[] vertices = new Vertice[getSelectedModelVerticeCount()];\n\t\tint index = 0;\n\t\tfor(int i = 0; i < getModelVerticesCount(); i++){\n\t\t\tselectedVertice = getModelVertice(i);\n\t\t\tif(selectedVertice.isSelected)\n\t\t\t\tvertices[index++] = selectedVertice;\n\t\t}\n\t\treturn vertices;\n\t}","public static Mesh[] getObjmesh() {\n return objmesh;\n }","public Vector2f[] getNormalisedVertexPositions() {\n Vertex3D[] vertices = mesh.getModel().getVertices();\n // Get Array of X and Y offsets for all vertices\n Vector2f[] vertexPositions = new Vector2f[vertices.length];\n for (int i = 0; i < vertices.length; i++) {\n Vector3f vertexPosition = vertices[i].getPosition();\n vertexPositions[i] = new Vector2f(vertexPosition.getX(), vertexPosition.getY());\n }\n\n // Add vertex positions to position in order to get their OpenGl coordinates\n for (int i = 0; i < vertexPositions.length; i++) {\n vertexPositions[i] = Vector2f.add(position, vertexPositions[i]);\n vertexPositions[i] = Vector2f.divide(\n vertexPositions[i],\n new Vector2f(Window.getSpanX(), Window.getSpanY()));\n }\n\n return vertexPositions;\n }","ArrayList> generateInitVertices() {\n ArrayList> vertices = new ArrayList>();\n for (int x = 0; x < width; x++) {\n ArrayList temp = new ArrayList();\n for (int y = 0; y < height; y++) {\n temp.add(new Vertex(x, y));\n }\n vertices.add(temp);\n }\n Random r = new Random();\n for (ArrayList vList : vertices) {\n for (Vertex v : vList) {\n if (v.x != 0) {\n v.outEdges.add(new Edge(v, vertices.get(v.x - 1).get(v.y), r.nextInt(1000)));\n }\n if (v.x != width - 1) {\n v.outEdges.add(new Edge(v, vertices.get(v.x + 1).get(v.y), r.nextInt(1000)));\n }\n if (v.y != 0) {\n v.outEdges.add(new Edge(v, vertices.get(v.x).get(v.y - 1), r.nextInt(1000)));\n }\n if (v.y != height - 1) {\n v.outEdges.add(new Edge(v, vertices.get(v.x).get(v.y + 1), r.nextInt(1000)));\n }\n }\n }\n return vertices;\n }","public boolean isBoxInBox(BBox BBox)\n {\n Vec3 sizeA = extents;\n Vec3 sizeB = BBox.extents;\n// System.out.println(\"sizeA: \" + sizeA);\n// System.out.println(\"mA: \" + m);\n// System.out.println(\"sizeB: \" + sizeB);\n// System.out.println(\"mB: \" + BBox.m);\n Vec3[] rotA, rotB;\n rotA = getInvRot();\n rotB = BBox.getInvRot();\n\n float[][] r = new float[3][3]; // Rotation from B to A\n float[][] ar = new float[3][3]; // absolute values of R matrix, to use with box extents\n float extentA, extentB, separation;\n int i, k;\n\n // Calculate B to A rotation matrix\n for (i = 0; i < 3; i++)\n {\n for (k = 0; k < 3; k++)\n {\n r[i][k] = rotA[i].dot(rotB[k]);\n ar[i][k] = abs(r[i][k]);\n }\n }\n\n // Vector separating the centers of Box B and of Box A\t\n Vec3 vSepWS = BBox.getCenterPoint().subtract(getCenterPoint());\n // Rotated into Box A's coordinates\n Vec3 vSepA = new Vec3(\n vSepWS.dot(rotA[0]),\n vSepWS.dot(rotA[1]),\n vSepWS.dot(rotA[2]));\n\n // Test if any of A's basis vectors separate the box\n for (i = 0; i < 3; i++)\n {\n extentA = sizeA.get(i);\n extentB = sizeB.dot(new Vec3(ar[i][0], ar[i][1], ar[i][2]));\n separation = abs(vSepA.get(i));\n\n if (separation > extentA + extentB)\n {\n return false;\n }\n }\n\n // Test if any of B's basis vectors separate the box\n for (k = 0; k < 3; k++)\n {\n extentA = sizeA.dot(new Vec3(ar[0][k], ar[1][k], ar[2][k]));\n extentB = sizeB.get(k);\n separation = abs(vSepA.dot(new Vec3(r[0][k], r[1][k], r[2][k])));\n\n if (separation > extentA + extentB)\n {\n return false;\n }\n }\n\n // Now test Cross Products of each basis vector combination ( A[i], B[k] )\n for (i = 0; i < 3; i++)\n {\n for (k = 0; k < 3; k++)\n {\n int i1 = (i + 1) % 3, i2 = (i + 2) % 3;\n int k1 = (k + 1) % 3, k2 = (k + 2) % 3;\n extentA = sizeA.get(i1) * ar[i2][k] + sizeA.get(i2) * ar[i1][k];\n extentB = sizeB.get(k1) * ar[i][k2] + sizeB.get(k2) * ar[i][k1];\n separation = abs(vSepA.get(i2) * r[i1][k] - vSepA.get(i1) * r[i2][k]);\n if (separation > extentA + extentB)\n {\n return false;\n }\n }\n }\n\n // No separating axis found, the boxes overlap\t\n return true;\n }","public int getVertices() {\n return mPolygonShapeSpec.getNumVertex();\n }","public int[] boxCoords(Vector3d v) {\r\n\t\t/* Check the bounds are valid */\r\n\t\tint x = (int)(v.x/box[0]);\r\n\t\tint y = (int)(v.y/box[1]);\r\n\t\tint z = (int)(v.z/box[2]);\r\n\t\tx = (x >= boxes[0] ? boxes[0]-1 : x);\r\n\t\ty = (y >= boxes[1] ? boxes[1]-1 : y);\r\n\t\tz = (z >= boxes[2] ? boxes[2]-1 : z);\r\n\t\tif (x < 0) x = 0;\r\n\t\tif (y < 0) y = 0;\r\n\t\tif (z < 0) z = 0;\r\n\t\treturn new int[] {x, y, z};\t\r\n\t}","public Iterable getVertices() {\n return mVertices.values();\n }","@Override\r\n\tpublic int getOrder() {\r\n\t\treturn vertices.size();\r\n\t}","public E3DVector3F getVertexPosA(){\r\n return vertices[0].getVertexPos();\r\n }","private List pegaVerticesFolha() {\n List verticesFolha = new ArrayList();\n\n for (Vertice vertice : this.pegaTodosOsVerticesDoGrafo()) {\n if (this.getGrauDeSaida(vertice) == 0) {\n verticesFolha.add(vertice);\n }\n }\n\n return verticesFolha;\n }","public Polygon getPolygon(double eyeDistance){\n //define the front two verticies of the currentTrack\n Point3D track_vertex0 = currentTrack.getVertex(0);\n Point3D track_vertex1 = currentTrack.getVertex(1);\n //use center point to define the center of the sphape\n int cubeSize = 3;\n\n Point3D front_up_left = new Point3D (centerPoint.x-cubeSize, centerPoint.y-cubeSize, centerPoint.z-cubeSize);\n Point3D front_down_left = new Point3D (centerPoint.x-cubeSize, centerPoint.y+cubeSize, centerPoint.z-cubeSize);\n Point3D front_down_right = new Point3D (centerPoint.x+cubeSize, centerPoint.y+cubeSize, centerPoint.z-cubeSize);\n Point3D front_up_right = new Point3D (centerPoint.x+cubeSize, centerPoint.y-cubeSize, centerPoint.z-cubeSize);\n\n Point3D back_up_left = new Point3D (front_up_left.x, front_up_left.y, centerPoint.z+cubeSize);\n Point3D back_down_left = new Point3D (front_down_left.x, front_down_left.y, centerPoint.z+cubeSize);\n Point3D back_down_right = new Point3D (front_down_right.x, front_down_right.y, centerPoint.z+cubeSize);\n Point3D back_up_right = new Point3D (front_up_right.x, front_up_right.y, centerPoint.z+cubeSize);\n\n //aranges verticies in the order they will be drawn\n Point3D[] cube_verticies = {front_up_left, front_down_left, front_down_right, front_up_right,\n front_up_left, back_up_left, back_up_right, front_up_right,\n front_down_right, back_down_right, back_up_right, back_down_right,\n back_down_left, back_up_left, back_down_left, front_down_left};\n\n int[] x_points = new int[16];\n int[] y_points = new int[16];\n //convert 3D points to 2D points\n for(int i=0;i<16;i++){\n if(cube_verticies[i].z <= 200){ //same fix as for the track positioning\n x_points[i] = (int) -cube_verticies[i].projectPoint3D(eyeDistance).getX();\n y_points[i] = (int) cube_verticies[i].projectPoint3D(eyeDistance).getY();\n }\n else{\n x_points[i] = (int) cube_verticies[i].projectPoint3D(eyeDistance).getX();\n y_points[i] = (int) cube_verticies[i].projectPoint3D(eyeDistance).getY();\n }\n }\n Polygon polygon = new Polygon(x_points, y_points, 16);\n return polygon;\n }","public Vertex[] getVertices() {\n return new Vertex[]{v1, v2};\n }","Set getVertices();","@Override\r\n public List getNeighbours(NavMesh mesh) { \r\n List neighbours = new ArrayList();\r\n \r\n if(pId > 0) neighbours.add(new NavMeshPolygon(pId));\r\n \r\n for(OffMeshEdge oe : outgoingEdges) {\r\n neighbours.add(oe.getTo());\r\n }\r\n \r\n return neighbours;\r\n }","@NonNull JavaBoundingBox[] collision();","public List getBoundingsOfCell() {\n\n\t\tfloat minXPoint = Float.POSITIVE_INFINITY;\n\t\tfloat maxXPoint = Float.NEGATIVE_INFINITY;\n\t\tfloat minYPoint = Float.POSITIVE_INFINITY;\n\t\tfloat maxYPoint = Float.NEGATIVE_INFINITY;\n\n\t\tfor (int i = 0; i < face.edges().size(); i++) {\n\n\t\t\tDCEL_Edge e = (DCEL_Edge) face.edges().get(i);\n\n\t\t\tArc2_Sweep arc = (Arc2_Sweep) e.reference;\n\n\t\t\t// Looking for most left located point of cell\n\t\t\tif (minXPoint > arc.minX().x) {\n\t\t\t\tminXPoint = arc.minX().x;\n\t\t\t}\n\t\t\t// Looking for most right located point of cell\n\t\t\tif (maxXPoint < arc.maxX().x) {\n\t\t\t\tmaxXPoint = arc.maxX().x;\n\t\t\t}\n\t\t\t// Looking for highest located point of cell\n\t\t\tif (minYPoint > arc.minY().y) {\n\t\t\t\tminYPoint = arc.minY().y;\n\t\t\t}\n\t\t\t// Looking for lowest located point of cell\n\t\t\tif (maxYPoint < arc.maxY().y) {\n\t\t\t\tmaxYPoint = arc.maxY().y;\n\t\t\t}\n\n\t\t}\n\n\t\tList
\\n * Note that the centroid is also the position of this sphere.\\n *
\\n */\\n @Override\\n default FramePoint3DReadOnly getCentroid()\\n {\\n return getPosition();\\n }\\n\\n /**\\n * Computes the coordinates of the possible intersections between a line and this sphere.\\n *\\n * In the case the line and this sphere do not intersect, this method returns {@code 0} and\\n * {@code firstIntersectionToPack} and {@code secondIntersectionToPack} remain unmodified.\\n *
\\n *\\n * @param line the line expressed in world coordinates that may intersect this\\n * sphere. Not modified.\\n * @param firstIntersectionToPack the coordinate in world of the first intersection. Can be\\n * {@code null}. Modified.\\n * @param secondIntersectionToPack the coordinate in world of the second intersection. Can be\\n * {@code null}. Modified.\\n * @return the number of intersections between the line and this sphere. It is either equal to 0, 1,\\n * or 2.\\n * @throws ReferenceFrameMismatchException if the frame argument is not expressed in the same\\n * reference frame as {@code this}.\\n */\\n default int intersectionWith(FrameLine3DReadOnly line, Point3DBasics firstIntersectionToPack, Point3DBasics secondIntersectionToPack)\\n {\\n return intersectionWith(line.getPoint(), line.getDirection(), firstIntersectionToPack, secondIntersectionToPack);\\n }\\n\\n /**\\n * Computes the coordinates of the possible intersections between a line and this sphere.\\n *\\n * In the case the line and this sphere do not intersect, this method returns {@code 0} and\\n * {@code firstIntersectionToPack} and {@code secondIntersectionToPack} remain unmodified.\\n *
\\n *\\n * @param line the line expressed in world coordinates that may intersect this\\n * sphere. Not modified.\\n * @param firstIntersectionToPack the coordinate in world of the first intersection. Can be\\n * {@code null}. Modified.\\n * @param secondIntersectionToPack the coordinate in world of the second intersection. Can be\\n * {@code null}. Modified.\\n * @return the number of intersections between the line and this sphere. It is either equal to 0, 1,\\n * or 2.\\n * @throws ReferenceFrameMismatchException if {@code line} is not expressed in the same reference\\n * frame as {@code this}.\\n */\\n default int intersectionWith(FrameLine3DReadOnly line, FramePoint3DBasics firstIntersectionToPack, FramePoint3DBasics secondIntersectionToPack)\\n {\\n return intersectionWith(line.getPoint(), line.getDirection(), firstIntersectionToPack, secondIntersectionToPack);\\n }\\n\\n /**\\n * Computes the coordinates of the possible intersections between a line and this sphere.\\n *\\n * In the case the line and this sphere do not intersect, this method returns {@code 0} and\\n * {@code firstIntersectionToPack} and {@code secondIntersectionToPack} remain unmodified.\\n *
\\n *\\n * @param line the line expressed in world coordinates that may intersect this\\n * sphere. Not modified.\\n * @param firstIntersectionToPack the coordinate in world of the first intersection. Can be\\n * {@code null}. Modified.\\n * @param secondIntersectionToPack the coordinate in world of the second intersection. Can be\\n * {@code null}. Modified.\\n * @return the number of intersections between the line and this sphere. It is either equal to 0, 1,\\n * or 2.\\n */\\n default int intersectionWith(Line3DReadOnly line, FramePoint3DBasics firstIntersectionToPack, FramePoint3DBasics secondIntersectionToPack)\\n {\\n return intersectionWith(line.getPoint(), line.getDirection(), firstIntersectionToPack, secondIntersectionToPack);\\n }\\n\\n /**\\n * Computes the coordinates of the possible intersections between a line and this sphere.\\n *\\n * In the case the line and this sphere do not intersect, this method returns {@code 0} and\\n * {@code firstIntersectionToPack} and {@code secondIntersectionToPack} remain unmodified.\\n *
\\n *\\n * @param line the line expressed in world coordinates that may intersect this\\n * sphere. Not modified.\\n * @param firstIntersectionToPack the coordinate in world of the first intersection. Can be\\n * {@code null}. Modified.\\n * @param secondIntersectionToPack the coordinate in world of the second intersection. Can be\\n * {@code null}. Modified.\\n * @return the number of intersections between the line and this sphere. It is either equal to 0, 1,\\n * or 2.\\n * @throws ReferenceFrameMismatchException if any of the frame arguments is not expressed in the\\n * same reference frame as {@code this}.\\n */\\n default int intersectionWith(Line3DReadOnly line, FixedFramePoint3DBasics firstIntersectionToPack, FixedFramePoint3DBasics secondIntersectionToPack)\\n {\\n return intersectionWith(line.getPoint(), line.getDirection(), firstIntersectionToPack, secondIntersectionToPack);\\n }\\n\\n /**\\n * Computes the coordinates of the possible intersections between a line and this sphere.\\n *\\n * In the case the line and this sphere do not intersect, this method returns {@code 0} and\\n * {@code firstIntersectionToPack} and {@code secondIntersectionToPack} remain unmodified.\\n *
\\n *\\n * @param line the line expressed in world coordinates that may intersect this\\n * sphere. Not modified.\\n * @param firstIntersectionToPack the coordinate in world of the first intersection. Can be\\n * {@code null}. Modified.\\n * @param secondIntersectionToPack the coordinate in world of the second intersection. Can be\\n * {@code null}. Modified.\\n * @return the number of intersections between the line and this sphere. It is either equal to 0, 1,\\n * or 2.\\n * @throws ReferenceFrameMismatchException if any of the arguments is not expressed in the same\\n * reference frame as {@code this}.\\n */\\n default int intersectionWith(FrameLine3DReadOnly line, FixedFramePoint3DBasics firstIntersectionToPack, FixedFramePoint3DBasics secondIntersectionToPack)\\n {\\n return intersectionWith(line.getPoint(), line.getDirection(), firstIntersectionToPack, secondIntersectionToPack);\\n }\\n\\n /**\\n * Computes the coordinates of the possible intersections between a line and this sphere.\\n *\\n * In the case the line and this sphere do not intersect, this method returns {@code 0} and\\n * {@code firstIntersectionToPack} and {@code secondIntersectionToPack} are set to\\n * {@link Double#NaN}.\\n *
\\n *\\n * @param pointOnLine a point expressed in world located on the infinitely long line.\\n * Not modified.\\n * @param lineDirection the direction expressed in world of the line. Not modified.s\\n * @param firstIntersectionToPack the coordinate in world of the first intersection. Can be\\n * {@code null}. Modified.\\n * @param secondIntersectionToPack the coordinate in world of the second intersection. Can be\\n * {@code null}. Modified.\\n * @return the number of intersections between the line and this sphere. It is either equal to 0, 1,\\n * or 2.\\n * @throws ReferenceFrameMismatchException if any of the frame arguments is not expressed in the\\n * same reference frame as {@code this}.\\n */\\n default int intersectionWith(FramePoint3DReadOnly pointOnLine,\\n FrameVector3DReadOnly lineDirection,\\n Point3DBasics firstIntersectionToPack,\\n Point3DBasics secondIntersectionToPack)\\n {\\n checkReferenceFrameMatch(pointOnLine, lineDirection);\\n return Sphere3DReadOnly.super.intersectionWith(pointOnLine, lineDirection, firstIntersectionToPack, secondIntersectionToPack);\\n }\\n\\n /**\\n * Computes the coordinates of the possible intersections between a line and this sphere.\\n *\\n * In the case the line and this sphere do not intersect, this method returns {@code 0} and\\n * {@code firstIntersectionToPack} and {@code secondIntersectionToPack} are set to\\n * {@link Double#NaN}.\\n *
\\n *\\n * @param pointOnLine a point expressed in world located on the infinitely long line.\\n * Not modified.\\n * @param lineDirection the direction expressed in world of the line. Not modified.s\\n * @param firstIntersectionToPack the coordinate in world of the first intersection. Can be\\n * {@code null}. Modified.\\n * @param secondIntersectionToPack the coordinate in world of the second intersection. Can be\\n * {@code null}. Modified.\\n * @return the number of intersections between the line and this sphere. It is either equal to 0, 1,\\n * or 2.\\n */\\n default int intersectionWith(Point3DReadOnly pointOnLine,\\n Vector3DReadOnly lineDirection,\\n FramePoint3DBasics firstIntersectionToPack,\\n FramePoint3DBasics secondIntersectionToPack)\\n {\\n if (firstIntersectionToPack != null)\\n firstIntersectionToPack.setReferenceFrame(getReferenceFrame());\\n if (secondIntersectionToPack != null)\\n secondIntersectionToPack.setReferenceFrame(getReferenceFrame());\\n return Sphere3DReadOnly.super.intersectionWith(pointOnLine, lineDirection, firstIntersectionToPack, secondIntersectionToPack);\\n }\\n\\n /**\\n * Computes the coordinates of the possible intersections between a line and this sphere.\\n *\\n * In the case the line and this sphere do not intersect, this method returns {@code 0} and\\n * {@code firstIntersectionToPack} and {@code secondIntersectionToPack} are set to\\n * {@link Double#NaN}.\\n *
\\n *\\n * @param pointOnLine a point expressed in world located on the infinitely long line.\\n * Not modified.\\n * @param lineDirection the direction expressed in world of the line. Not modified.s\\n * @param firstIntersectionToPack the coordinate in world of the first intersection. Can be\\n * {@code null}. Modified.\\n * @param secondIntersectionToPack the coordinate in world of the second intersection. Can be\\n * {@code null}. Modified.\\n * @return the number of intersections between the line and this sphere. It is either equal to 0, 1,\\n * or 2.\\n * @throws ReferenceFrameMismatchException if any of the frame arguments is not expressed in the\\n * same reference frame as {@code this}.\\n */\\n default int intersectionWith(Point3DReadOnly pointOnLine,\\n Vector3DReadOnly lineDirection,\\n FixedFramePoint3DBasics firstIntersectionToPack,\\n FixedFramePoint3DBasics secondIntersectionToPack)\\n {\\n if (firstIntersectionToPack != null)\\n checkReferenceFrameMatch(firstIntersectionToPack);\\n if (secondIntersectionToPack != null)\\n checkReferenceFrameMatch(secondIntersectionToPack);\\n return Sphere3DReadOnly.super.intersectionWith(pointOnLine, lineDirection, firstIntersectionToPack, secondIntersectionToPack);\\n }\\n\\n /**\\n * Computes the coordinates of the possible intersections between a line and this sphere.\\n *\\n * In the case the line and this sphere do not intersect, this method returns {@code 0} and\\n * {@code firstIntersectionToPack} and {@code secondIntersectionToPack} are set to\\n * {@link Double#NaN}.\\n *
\\n *\\n * @param pointOnLine a point expressed in world located on the infinitely long line.\\n * Not modified.\\n * @param lineDirection the direction expressed in world of the line. Not modified.s\\n * @param firstIntersectionToPack the coordinate in world of the first intersection. Can be\\n * {@code null}. Modified.\\n * @param secondIntersectionToPack the coordinate in world of the second intersection. Can be\\n * {@code null}. Modified.\\n * @return the number of intersections between the line and this sphere. It is either equal to 0, 1,\\n * or 2.\\n * @throws ReferenceFrameMismatchException if either {@code pointOnLine} or {@code lineDirection} is\\n * not expressed in the same reference frame as\\n * {@code this}.\\n */\\n default int intersectionWith(FramePoint3DReadOnly pointOnLine,\\n FrameVector3DReadOnly lineDirection,\\n FramePoint3DBasics firstIntersectionToPack,\\n FramePoint3DBasics secondIntersectionToPack)\\n {\\n checkReferenceFrameMatch(pointOnLine, lineDirection);\\n if (firstIntersectionToPack != null)\\n firstIntersectionToPack.setReferenceFrame(getReferenceFrame());\\n if (secondIntersectionToPack != null)\\n secondIntersectionToPack.setReferenceFrame(getReferenceFrame());\\n return Sphere3DReadOnly.super.intersectionWith(pointOnLine, lineDirection, firstIntersectionToPack, secondIntersectionToPack);\\n }\\n\\n /**\\n * Computes the coordinates of the possible intersections between a line and this sphere.\\n *\\n * In the case the line and this sphere do not intersect, this method returns {@code 0} and\\n * {@code firstIntersectionToPack} and {@code secondIntersectionToPack} are set to\\n * {@link Double#NaN}.\\n *
\\n *\\n * @param pointOnLine a point expressed in world located on the infinitely long line.\\n * Not modified.\\n * @param lineDirection the direction expressed in world of the line. Not modified.s\\n * @param firstIntersectionToPack the coordinate in world of the first intersection. Can be\\n * {@code null}. Modified.\\n * @param secondIntersectionToPack the coordinate in world of the second intersection. Can be\\n * {@code null}. Modified.\\n * @return the number of intersections between the line and this sphere. It is either equal to 0, 1,\\n * or 2.\\n * @throws ReferenceFrameMismatchException if any of the arguments is not expressed in the same\\n * reference frame as {@code this}.\\n */\\n default int intersectionWith(FramePoint3DReadOnly pointOnLine,\\n FrameVector3DReadOnly lineDirection,\\n FixedFramePoint3DBasics firstIntersectionToPack,\\n FixedFramePoint3DBasics secondIntersectionToPack)\\n {\\n checkReferenceFrameMatch(pointOnLine, lineDirection);\\n if (firstIntersectionToPack != null)\\n checkReferenceFrameMatch(firstIntersectionToPack);\\n if (secondIntersectionToPack != null)\\n checkReferenceFrameMatch(secondIntersectionToPack);\\n return Sphere3DReadOnly.super.intersectionWith(pointOnLine, lineDirection, firstIntersectionToPack, secondIntersectionToPack);\\n }\\n\\n /** {@inheritDoc} */\\n @Override\\n default void getBoundingBox(BoundingBox3DBasics boundingBoxToPack)\\n {\\n Sphere3DReadOnly.super.getBoundingBox(boundingBoxToPack);\\n }\\n\\n /** {@inheritDoc} */\\n @Override\\n default void getBoundingBox(ReferenceFrame destinationFrame, BoundingBox3DBasics boundingBoxToPack)\\n {\\n EuclidFrameShapeTools.boundingBoxSphere3D(this, destinationFrame, boundingBoxToPack);\\n }\\n\\n /** {@inheritDoc} */\\n @Override\\n default FrameShape3DPoseReadOnly getPose()\\n {\\n return null;\\n }\\n\\n /** {@inheritDoc} */\\n @Override\\n FixedFrameSphere3DBasics copy();\\n\\n /**\\n * Gets a representative {@code String} of this frame sphere 3D given a specific format to use.\\n *\\n * Using the default format {@link EuclidCoreIOTools#DEFAULT_FORMAT}, this provides a {@code String}\\n * as follows:\\n *\\n *
\\n * Sphere 3D: [position: (-0.362, -0.617, 0.066 ), radius: 0.906] - worldFrame\\n *\\n * \\n */\\n @Override\\n default String toString(String format)\\n {\\n return EuclidFrameShapeIOTools.getFrameSphere3DString(format, this);\\n }\\n}\",\n \"@Test\\n public void testSerializeDeserialize() throws GeometryException, AlgebraException, IOException, ClassNotFoundException {\\n final UniformRandomizer randomizer = new UniformRandomizer(new Random());\\n final double alphaEuler1 = 0.0;\\n final double betaEuler1 = 0.0;\\n final double gammaEuler1 = 0.0;\\n final double alphaEuler2 = randomizer.nextDouble(MIN_ANGLE_DEGREES,\\n MAX_ANGLE_DEGREES) * Math.PI / 180.0;\\n final double betaEuler2 = randomizer.nextDouble(MIN_ANGLE_DEGREES,\\n MAX_ANGLE_DEGREES) * Math.PI / 180.0;\\n final double gammaEuler2 = randomizer.nextDouble(MIN_ANGLE_DEGREES,\\n MAX_ANGLE_DEGREES) * Math.PI / 180.0;\\n\\n final double horizontalFocalLength1 = randomizer.nextDouble(MIN_FOCAL_LENGTH,\\n MAX_FOCAL_LENGTH);\\n final double verticalFocalLength1 = randomizer.nextDouble(MIN_FOCAL_LENGTH,\\n MAX_FOCAL_LENGTH);\\n final double horizontalFocalLength2 = randomizer.nextDouble(MIN_FOCAL_LENGTH,\\n MAX_FOCAL_LENGTH);\\n final double verticalFocalLength2 = randomizer.nextDouble(MIN_FOCAL_LENGTH,\\n MAX_FOCAL_LENGTH);\\n\\n final double skewness1 = randomizer.nextDouble(MIN_SKEWNESS, MAX_SKEWNESS);\\n final double skewness2 = randomizer.nextDouble(MIN_SKEWNESS, MAX_SKEWNESS);\\n\\n final double horizontalPrincipalPoint1 = randomizer.nextDouble(\\n MIN_PRINCIPAL_POINT, MAX_PRINCIPAL_POINT);\\n final double verticalPrincipalPoint1 = randomizer.nextDouble(\\n MIN_PRINCIPAL_POINT, MAX_PRINCIPAL_POINT);\\n final double horizontalPrincipalPoint2 = randomizer.nextDouble(\\n MIN_PRINCIPAL_POINT, MAX_PRINCIPAL_POINT);\\n final double verticalPrincipalPoint2 = randomizer.nextDouble(\\n MIN_PRINCIPAL_POINT, MAX_PRINCIPAL_POINT);\\n\\n final double cameraSeparation = randomizer.nextDouble(MIN_CAMERA_SEPARATION,\\n MAX_CAMERA_SEPARATION);\\n\\n final Point3D center1 = new InhomogeneousPoint3D(\\n randomizer.nextDouble(MIN_RANDOM_VALUE, MAX_RANDOM_VALUE),\\n randomizer.nextDouble(MIN_RANDOM_VALUE, MAX_RANDOM_VALUE),\\n randomizer.nextDouble(MIN_RANDOM_VALUE, MAX_RANDOM_VALUE));\\n final Point3D center2 = new InhomogeneousPoint3D(\\n center1.getInhomX() + cameraSeparation,\\n center1.getInhomY() + cameraSeparation,\\n center1.getInhomZ() + cameraSeparation);\\n\\n final Rotation3D rotation1 = new MatrixRotation3D(alphaEuler1, betaEuler1,\\n gammaEuler1);\\n final Rotation3D rotation2 = new MatrixRotation3D(alphaEuler2, betaEuler2,\\n gammaEuler2);\\n\\n final PinholeCameraIntrinsicParameters intrinsic1 =\\n new PinholeCameraIntrinsicParameters(horizontalFocalLength1,\\n verticalFocalLength1, horizontalPrincipalPoint1,\\n verticalPrincipalPoint1, skewness1);\\n final PinholeCameraIntrinsicParameters intrinsic2 =\\n new PinholeCameraIntrinsicParameters(horizontalFocalLength2,\\n verticalFocalLength2, horizontalPrincipalPoint2,\\n verticalPrincipalPoint2, skewness2);\\n\\n final PinholeCamera camera1 = new PinholeCamera(intrinsic1, rotation1,\\n center1);\\n final PinholeCamera camera2 = new PinholeCamera(intrinsic2, rotation2,\\n center2);\\n\\n final FundamentalMatrix fundMatrix1 = new FundamentalMatrix(camera1, camera2);\\n\\n // serialize and deserialize\\n final byte[] bytes = SerializationHelper.serialize(fundMatrix1);\\n final FundamentalMatrix fundMatrix2 = SerializationHelper.deserialize(bytes);\\n\\n // check\\n assertEquals(fundMatrix1.getInternalMatrix(), fundMatrix2.getInternalMatrix());\\n }\",\n \"public EarthGeometry(){\\n\\t\\tgcl1 = new GeodeticCalculator();\\n\\t\\trnd1 = new Random(56789);\\n\\t}\",\n \"public void calculate() {\\n\\t\\t\\n\\t\\tHashMap