// TODO: option flush edges
// Add fake profiles on the ends, this might be a option later for
// flush edges !
SlicePlane startSlicePlaneend1 = planesToSlice.getList().get(0);
SlicePlane slicePlane1 = new SlicePlane(startSlicePlaneend1
.getSketch().clone(), new Plane(new Vec3D(0, 0,
(startSlicePlaneend1.getPlane().z)
- SETTINGS.chair_slat_end_size),
new Vec3D(0, 0, -1)));
slicePlane1.destroy();//a bit of a hack make sure that our temp slice is deleted later
slicePlane1.getSketch().removeLegs(); // remove any leg shapes
slicePlane1.getSketch().build();
planesToSlice.add(0, slicePlane1);
// Add fake profiles on the ends
SlicePlane startSlicePlaneend2 = planesToSlice.get(planesToSlice
.size() - 1);
SlicePlane slicePlane2 = new SlicePlane(startSlicePlaneend2
.getSketch().clone(), new Plane(new Vec3D(0, 0,
(startSlicePlaneend2.getPlane().z)
+ SETTINGS.chair_slat_end_size),
new Vec3D(0, 0, -1)));
slicePlane2.destroy();//a bit of a hack make sure that our temp slice is deleted later
slicePlane2.getSketch().removeLegs(); // remove any leg shapes
slicePlane2.getSketch().build();
planesToSlice.add(slicePlane2);
}
// Add fake profiles on the ends
float step = crossSliceSelection.spacing / guideSpline.getlength();
float start = Math.min(crossSliceSelection.start,
crossSliceSelection.end);
float end = Math
.max(crossSliceSelection.start, crossSliceSelection.end);
if (SETTINGS.DEBUG)
guideSpline.debugPercent = start;
//Clear dubugging info off planes
if (SETTINGS.DEBUG) {
for (int j = 0; j < planesToSlice.size(); j++) {
SlicePlane currentPlaneY = planesToSlice.get(j);
currentPlaneY.debugIntersectionPoints.clear();
currentPlaneY.debugIntersectionPointsTop.clear();
currentPlaneY.debugIntersectionPointsBottom.clear();
}
}
/*
* Step though the spline to slice
*
* <pre>
*
* start
* /|/|/|/|/|
* 0.1f -----------< --- (crossSliceSelection)
* / / / / /
* 0.2f -----------<
* / / / / /
* 0.3f -----------<
* |/|/|/|/|/
* end
*
* </pre>
*/
for (float i = start; i <= end; i += step) {
if (guideSpline == null || i > 1)
return;
Vec2D sPos = guideSpline.getPos(i);
if(sPos == null)
return;
Vec3D vecPos = new Vec3D(sPos.x,
sPos.y, 0);
Vec3D vecDir = new Vec3D(guideSpline.getPerpendicular(i).x,
guideSpline.getPerpendicular(i).y, 0);
vecDir = vecDir.rotateZ(crossSliceSelection.offsetRotation);
//vecDir = vecDir.rotateZ((float) (Math.PI ));
// do we want to add a strengthening beam to the leg
if (crossSliceSelection.tieToLeg) {
SketchPoint point1 = (SketchPoint) guideSpline.get(0);
SketchPoint point2 = (SketchPoint) guideSpline.get(1);
Vec2D dir2D = point1.sub(point2).normalize();
dir2D.rotate((float) (Math.PI / 2));
vecPos = new Vec3D(point1.x, point1.y, 0);
vecDir = new Vec3D(dir2D.x, dir2D.y, 0);
}
SlicePlane slicePlane = new SlicePlane(new Plane(vecPos, vecDir));
slicePlane.setCrossSliceSelection(crossSliceSelection);
//slicePlane.getPlane().normal.rotateZ((float) -(Math.PI/2));
SketchPath topLine = new SketchPath(null);
SketchPath bottomLine = new SketchPath(null);
topLine.setClosed(false);
bottomLine.setClosed(false);
/*
* Slice up each plane
*
* <pre>
*
* 1 2 3 4 5 -> (currentPlaneY) go through each plane
*
* | | | | |
* ---------< (crossSliceSelection) calculate intersects
* | | | | |
* | | | | |
* |\ \ \ \ \
* | \ \ \ \ \
* | \ \ \ \ \
* | | | |
* | |
* | |
*
* </pre>
*/
for (int j = 0; j < planesToSlice.size(); j++) {
SlicePlane currentPlaneY = planesToSlice.get(j);
// get the spline we want to produce cross sections along
// do we want to generate planes across the whole profile or
// just the current sketch?
//TODO: crop to outline minus leg!
Object spline = null;
if (crossSliceSelection.cropToCurrentShape) {
//if(crossSliceSelection.path instanceof SketchSpline)
//spline = crossSliceSelection.path;
spline = currentPlaneY.getSketch().getFirst(); ////THIS IS WRONG TODO:
} else {
if (currentPlaneY.getSketch().getSketchShapes().sketchOutlines
.getOutterOutline() == null)
return;
spline = currentPlaneY.getSketch().getSketchShapes().sketchOutlines
.getOutterOutline().getPath();
}
/** GUIDE SKETCHSPLINE
*
* <pre>
* intersect points based on center of spline and width
* ^
* ___|__ __|_____|_____
* \/ _|_ \ / |_____|_____
* /\ / |\ \/ /| |
* | \ \____/
*
* </pre>
**/
// we want to produce cross sections just across the current
// sketch
if (spline != null && spline instanceof SketchSpline) {
SketchSpline currentSpline = (SketchSpline) spline;
//LOGGER.info("slices on SketchSpline");
if (currentSpline == null) {
crossSliceSelection.destroy(null);
return;
}
currentSpline = currentSpline;
Vec2D topIntersect = null;
Vec2D bottomIntersect = null;
Vec2D intersectX = new Vec2D(-1, -1);
Vec2D vecPosOnSpline = currentSpline.getPos(i);
if(vecPosOnSpline != null){
vecPos = new Vec3D(vecPosOnSpline.x,
vecPosOnSpline.y,
currentPlaneY.getPlane().z);
Vec2D posPerp = currentSpline.getPerpendicular(i);
float percent = -1f;
Vec2D percentVec = new Vec2D(-1, -1);
posPerp = posPerp.rotate(crossSliceSelection.offsetRotation);
currentPlaneY.getIntersectionCentre(slicePlane,
currentSpline, i, percentVec, intersectX);
if(intersectX.x != -1 && intersectX.y!=-1){
float splineWidth = currentSpline.getOffsetSize();
splineWidth = currentSpline.getOffsetSize(i);
// float splineIntersectPercent = percentVec.x;
// if (splineIntersectPercent != -1) {
Vec2D topIntersectY = null;
Vec2D bottomIntersectY = null;
float dist = 0;
float neartestDist = -1;
Vec2D tempPos = percentVec.copy();// currentSpline.getPos(percentVec.x);
Vec2D tempDir = posPerp.copy();// currentSpline.getPerpendicular(percentVec.x);
if (tempDir == null)
break;
tempDir = tempDir.normalize();
topIntersect = intersectX.add(new Vec2D(0, splineWidth));
bottomIntersect = intersectX.add(new Vec2D(0, -splineWidth));
// Switch what side slots are added to
// slots along Y
Vec2D slotPos = new Vec2D(tempPos.x, tempPos.y);
Vec2D slotDir = null;
if (!crossSliceSelection.flipSide) {
slotDir = new Vec2D(vecDir.x, vecDir.y);
} else {
slotDir = new Vec2D(-vecDir.x, -vecDir.y);
}
// slotPos.addSelf(slotDir.scale(100));
float offsetToEdge = -1;
if (!crossSliceSelection.flipSide) {
offsetToEdge = 1;
} else {
offsetToEdge = -1;
}
if (!currentPlaneY.guide) {
SliceSlot slot = new SliceSlot(slicePlane, slotPos,
slotDir, (-splineWidth - offsetToEdge),
SETTINGS.materialThickness);
slot.swap();
slot.setOnEdge(new Vec2D(0, 1));
if(crossSliceSelection.getCapType() != CrossSliceSelection.CAP_INSIDE)
slot.makesEdge = true;
currentPlaneY.getSketch().getSlots().add(slot);
}
if (!currentPlaneY.guide) {
if (!crossSliceSelection.flipSide) {
if (j != 0 && j != planesToSlice.size() - 1 ){
float yPosSlot = intersectX.y + (splineWidth);
SliceSlot slot = new SliceSlot(
currentPlaneY,
new Vec2D(intersectX.x,yPosSlot),
new Vec2D(-1, 0), splineWidth,
SETTINGS.materialThickness);
if(crossSliceSelection.getCapType() != CrossSliceSelection.CAP_INSIDE)
slot.makesEdge = true;
slot.setOnEdge(new Vec2D(0,-1)); // these slots start from the middle so this doesn't work, flip slots.
//LOGGER.info("X " + slot.getPos().x + " Y " + slot.getPos().y );
slicePlane
.getSketch()
.getSlots()
.add(slot);
}
} else {
if (j != 0 && j != planesToSlice.size() - 1){
SliceSlot slot = new SliceSlot(
currentPlaneY,
new Vec2D(intersectX.x,
intersectX.y
- (splineWidth)),
new Vec2D(1, 0), splineWidth,
SETTINGS.materialThickness);
slot.setOnEdge(new Vec2D(0, -1));
if(crossSliceSelection.getCapType() != CrossSliceSelection.CAP_INSIDE)
slot.makesEdge = true;
slicePlane
.getSketch()
.getSlots()
.add(slot);
}
}
}
// if(topIntersect != null){
Vec3D tempVec = new Vec3D(bottomIntersect.x,
bottomIntersect.y, 0);
tempVec = slicePlane.getWorldPosIntersect(tempVec);
if (SETTINGS.DEBUG) {
currentPlaneY.debugIntersectionPoints.add(slotPos);
currentPlaneY.debugIntersectionPointsTop.add(tempPos
.scale(tempDir));
currentPlaneY.debugIntersectionPointsBottom.add(tempPos
.scale(tempDir.scale(-1)));
}
topLine.add(new SketchPoint(bottomIntersect));
bottomLine.add(new SketchPoint(topIntersect));
}
}
}
//}
/* ACROSS SKETCHPATH */
/**
* Find intersections across cross section
*
* <pre>
* currentPath
* ^
* |
* ------ x1 -> (topIntersect)
* | \/ -------------------------> (crossSliceSelection)
* | /\
* | / /
* \ / \
* \_/____\
* /
* x2 -> (bottomIntersect)
* </pre>
*/
else if (spline instanceof SketchPath) {
SketchPath currentPath = (SketchPath) spline;
vecPos = new Vec3D(vecPos.x, vecPos.y,currentPlaneY.getPlane().z);
//always crop to shape as we work out the correct shape earlier
List<List<Vec2D>> points = currentPlaneY.getIntersection(
slicePlane, true,
currentPath);
if (points != null && points.size() > 1) {
Vec2D topIntersect = null;
Vec2D bottomIntersect = null;
Vec2D topIntersectY = null;
Vec2D bottomIntersectY = null;
Vec2D topIntersectX = null;
Vec2D bottomIntersectX = null;
float dist = 0;
float neartestDist = -1;
Vec2D vecStart = new Vec2D(vecPos.x, vecPos.y);
//find the closest point
for (int k = 0; k < points.size(); k++) {
Vec2D vec2d = (Vec2D) points.get(k).get(0);
Vec2D vec2dX = (Vec2D) points.get(k).get(1);
Vec3D vec3d = new Vec3D(vec2dX.x, vec2dX.y,vecPos.z);
float d = vecStart.distanceTo(vec2dX);
//Display intersects in debug mode
if (SETTINGS.DEBUG) {
currentPlaneY.debugIntersectionPoints
.add(vec2dX);
currentPlaneY.debugIntersetStart = new Vec2D(
vecPos.x, vecPos.y);
}
if (d < neartestDist || neartestDist == -1) {
neartestDist = d;
topIntersect = vec2d;
topIntersectX = vec2dX;
}
}
float MIN_DUPLICATE_DIST = 2;
//Remove the closest point
for (int k = 0; k < points.size(); k++) {
Vec2D vec2d = (Vec2D) points.get(k).get(0);
Vec2D vec2dx = (Vec2D) points.get(k).get(1);
float distToLastIntersect = topIntersectX
.distanceTo(vec2dx);
if (vec2d.equals(topIntersect)
|| distToLastIntersect < MIN_DUPLICATE_DIST) {
points.remove(k);
k--;
}
}
//find the next closest intersect!
neartestDist = -1;
for (int k = 0; k < points.size(); k++) {
Vec2D vec2d = (Vec2D) points.get(k).get(0);
Vec2D vec2dX = (Vec2D) points.get(k).get(1);
Vec3D vec3d = new Vec3D(vec2d.x, vec2d.y,
currentPlaneY.getPlane().z);
float d = vecStart.distanceTo(vec2dX);
if ((d < neartestDist && vec2d != topIntersect)
|| neartestDist == -1) {