Cylinder.java

Go to the documentation of this file.

 
package eu.mihosoft.vrl.v3d;
 
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
 
import eu.mihosoft.vrl.v3d.parametrics.LengthParameter;
 
// TODO: Auto-generated Javadoc
public class Cylinder extends Primitive {
    private static final double MINIMUM_RADIUS=0.001;
    private Vector3d start;
    
    private Vector3d end;
    
    private double startRadius;
    
    private double endRadius;
    private static int defaultNumSlices=16;
 
    private int numSlices=defaultNumSlices;
 
    private final PropertyStorage properties = new PropertyStorage();
 
    public Cylinder() {
        this.start = new Vector3d(0, -0.5, 0);
        this.end = new Vector3d(0, 0.5, 0);
        this.startRadius = 1;
        this.endRadius = 1;
        this.numSlices = defaultNumSlices;
    }
 
    public Cylinder(Vector3d start, Vector3d end, double radius, int numSlices) {
        this.start = start;
        this.end = end;
        this.startRadius = radius<MINIMUM_RADIUS?MINIMUM_RADIUS:radius;
        this.endRadius = radius<MINIMUM_RADIUS?MINIMUM_RADIUS:radius;
        this.numSlices = numSlices;
    }
 
    public Cylinder(Vector3d start, Vector3d end, double startRadius, double endRadius, int numSlices) {
        this.start = start;
        this.end = end;
        this.startRadius = startRadius<MINIMUM_RADIUS?MINIMUM_RADIUS:startRadius;
        this.endRadius = endRadius<MINIMUM_RADIUS?MINIMUM_RADIUS:endRadius;
        this.numSlices = numSlices;
    }
 
    public Cylinder(double radius, double height, int numSlices) {
        this.start = Vector3d.ZERO;
        this.end = Vector3d.Z_ONE.times(height);
        this.startRadius = radius<MINIMUM_RADIUS?MINIMUM_RADIUS:radius;
        this.endRadius = radius<MINIMUM_RADIUS?MINIMUM_RADIUS:radius;
        this.numSlices = numSlices;
    }
 
    public Cylinder(double startRadius, double endRadius, double height, int numSlices) {
        this.start = Vector3d.ZERO;
        this.end = Vector3d.Z_ONE.times(height);
        this.startRadius = startRadius<MINIMUM_RADIUS?MINIMUM_RADIUS:startRadius;
        this.endRadius = endRadius<MINIMUM_RADIUS?MINIMUM_RADIUS:endRadius;
        this.numSlices = numSlices;
    }
    public Cylinder(double radius, double height) {
        this.start = Vector3d.ZERO;
        this.end = Vector3d.Z_ONE.times(height);
        this.startRadius = radius<MINIMUM_RADIUS?MINIMUM_RADIUS:radius;
        this.endRadius = radius<MINIMUM_RADIUS?MINIMUM_RADIUS:radius;
    }
 
    public Cylinder(double startRadius, double endRadius, double height) {
        this.start = Vector3d.ZERO;
        this.end = Vector3d.Z_ONE.times(height);
        this.startRadius = startRadius<MINIMUM_RADIUS?MINIMUM_RADIUS:startRadius;
        this.endRadius = endRadius<MINIMUM_RADIUS?MINIMUM_RADIUS:endRadius;
    }
    public Cylinder(LengthParameter startRadius, LengthParameter endRadius, LengthParameter height, int numSlices) {
        this(startRadius.getMM(),endRadius.getMM(),height.getMM(),numSlices);
        parametrics.add(startRadius);
        parametrics.add(endRadius);
        parametrics.add(height);
    }
    public Cylinder(LengthParameter startRadius,  LengthParameter height, int numSlices) {
        this(startRadius,startRadius,height,numSlices);
    }
    public Cylinder(LengthParameter startRadius, LengthParameter endRadius, LengthParameter height) {
        this(startRadius.getMM(),endRadius.getMM(),height.getMM());
        parametrics.add(startRadius);
        parametrics.add(endRadius);
        parametrics.add(height);
    }
    public Cylinder(LengthParameter startRadius,  LengthParameter height) {
        this(startRadius,startRadius,height);
    }
    /* (non-Javadoc)
     * @see eu.mihosoft.vrl.v3d.Primitive#toPolygons()
     */
    @Override
    public List<Polygon> toPolygons() {
        if(startRadius<=0)
            throw new NumberFormatException("startRadius can not be negative");
        if(endRadius<=0)
            throw new NumberFormatException("endRadius can not be negative");
        if(numSlices<3)
            throw new NumberFormatException("Slices can not be less than 3");
 
        final Vector3d s = getStart();
        Vector3d e = getEnd();
        final Vector3d ray = e.minus(s);
        if(ray.z<=0)
            throw new NumberFormatException("Z can not be negative");
        
        final Vector3d axisZ = ray.normalized();
        boolean isY = (Math.abs(axisZ.y) > 0.5);
        final Vector3d axisX = new Vector3d(isY ? 1 : 0, !isY ? 1 : 0, 0).
                cross(axisZ).normalized();
        final Vector3d axisY = axisX.cross(axisZ).normalized();
        Vertex startV = new Vertex(s, axisZ.negated());
        Vertex endV = new Vertex(e, axisZ.normalized());
        List<Polygon> polygons = new ArrayList<>();
 
        for (int i = 0; i < numSlices; i++) {
            double t0 = i / (double) numSlices, t1 = (i + 1) / (double) numSlices;
            polygons.add(new Polygon(Arrays.asList(
                    startV,
                    cylPoint(axisX, axisY, axisZ, ray, s, startRadius, 0, t0, -1),
                    cylPoint(axisX, axisY, axisZ, ray, s, startRadius, 0, t1, -1)),
                    properties
            ));
            polygons.add(new Polygon(Arrays.asList(
                    cylPoint(axisX, axisY, axisZ, ray, s, startRadius, 0, t1, 0),
                    cylPoint(axisX, axisY, axisZ, ray, s, startRadius, 0, t0, 0),
                    cylPoint(axisX, axisY, axisZ, ray, s, endRadius, 1, t0, 0),
                    cylPoint(axisX, axisY, axisZ, ray, s, endRadius, 1, t1, 0)),
                    properties
            ));
            polygons.add(new Polygon(
                    Arrays.asList(
                            endV,
                            cylPoint(axisX, axisY, axisZ, ray, s, endRadius, 1, t1, 1),
                            cylPoint(axisX, axisY, axisZ, ray, s, endRadius, 1, t0, 1)),
                    properties
            ));
        }
 
        return polygons;
    }
 
    private Vertex cylPoint(
            Vector3d axisX, Vector3d axisY, Vector3d axisZ, Vector3d ray, Vector3d s,
            double r, double stack, double slice, double normalBlend) {
        double angle = slice * Math.PI * 2;
        Vector3d out = axisX.times(Math.cos(angle)).plus(axisY.times(Math.sin(angle)));
        Vector3d pos = s.plus(ray.times(stack)).plus(out.times(r));
        Vector3d normal = out.times(1.0 - Math.abs(normalBlend)).plus(axisZ.times(normalBlend));
        return new Vertex(pos, normal);
    }
 
    public Vector3d getStart() {
        return start;
    }
 
    public void setStart(Vector3d start) {
        this.start = start;
    }
 
    public Vector3d getEnd() {
        return end;
    }
 
    public void setEnd(Vector3d end) {
        this.end = end;
    }
 
    public double getStartRadius() {
        return startRadius;
    }
 
    public void setStartRadius(double radius) {
        this.startRadius = radius;
    }
 
    public double getEndRadius() {
        return endRadius;
    }
 
    public void setEndRadius(double radius) {
        this.endRadius = radius;
    }
 
    public int getNumSlices() {
        return numSlices;
    }
 
    public void setNumSlices(int numSlices) {
        this.numSlices = numSlices;
    }
 
    /* (non-Javadoc)
     * @see eu.mihosoft.vrl.v3d.Primitive#getProperties()
     */
    @Override
    public PropertyStorage getProperties() {
        return properties;
    }
 
 
 
}