Package cc.sketchchair.sketch

Examples of cc.sketchchair.sketch.SketchPath


      if (spline instanceof SketchSpline) {

      }

      if (spline != null && spline instanceof SketchPath) {
        SketchPath path = (SketchPath) spline;
        path.setClosed(true);
        this.crossSliceSelections.add(new CrossSliceSelection(path,
            extrudeSlice, this.endCoverPercent,
            this.startCoverPercent, SETTINGS.DEFAULT_SLAT_SPACING,
            this));
        GLOBAL.uiTools.setCurrentTool(UITools.CROSSSLICE_EDIT);
View Full Code Here


        if (this.selectedPlanes.size() > 0) {
          SlicePlane tempPlane = this.selectedPlanes.get(0);
          ;
          Vec2D tempP = new Vec2D(GLOBAL.uiTools.mouseX,
              GLOBAL.uiTools.mouseY);
          SketchPath tempPath = new SketchPath(tempPlane.getSketch());
          tempPath.add(new SketchPoint(GLOBAL.uiTools
              .getPointOnPlane(tempP, tempPlane.getPlane())));
          tempPath.add(new SketchPoint(GLOBAL.uiTools
              .getPointOnPlane(tempP, tempPlane.getPlane()).add(
                  100, 0)));
          tempPath.setIsContructionLine(true);
          creossSelectionTempOver = new CrossSliceSelection(tempPath,
              tempPath.getParentSketch().getOnSketchPlane(), 0,
              1, 1, this);
          creossSelectionTempOver.type = CrossSliceSelection.PLANE;
          creossSelectionTempOver.select();
          creossSelectionTempOver.tempSlice = true;
View Full Code Here

      Vec2D pointOnPlan = GLOBAL.uiTools.getPointOnPlane(new Vec2D(
          GLOBAL.uiTools.mouseX, GLOBAL.uiTools.mouseY), this.plane
          .getPlane());

      if (clicks == 1) {
        SketchPath tempP = (SketchPath) this.path;
        tempP.get(0).set(pointOnPlan);
      }

      if (clicks == 2) {
        SketchPath tempP = (SketchPath) this.path;
        tempP.get(1).set(pointOnPlan);
      }

      if (clicks == 3) {
        this.end = 1;
        editing = false;
View Full Code Here

    SlicePlane slicePlane = new SlicePlane(new Plane(vecPosStart, vecDir));
   
    slicePlane.setCrossSliceSelection(crossSliceSelection);
    //LOGGER.info("vecDir"+Math.atan2(vecDir.x, vecDir.y));
   
    SketchPath sketchPath = new SketchPath(slicePlane.getSketch());
    /*
    float offsetWidth = widthBetweenPlanes / 2;
    sketchPath.add(new SketchPoint(startX + offsetWidth
        + crossSliceSelection.boarderX, -crossSliceSelection.boarderY));
    sketchPath.add(new SketchPoint(startX
        - (offsetWidth + crossSliceSelection.boarderX),
        -crossSliceSelection.boarderY));
    sketchPath.add(new SketchPoint(startX
        - (offsetWidth + crossSliceSelection.boarderX), pLen
        + crossSliceSelection.boarderY));
    sketchPath.add(new SketchPoint(startX + offsetWidth
        + crossSliceSelection.boarderX, pLen
        + crossSliceSelection.boarderY));
     */
   
    float penetration = 0.01f;
   
    float minZ = sign*planesToSlice.getMinZ();
    float maxZ = sign*planesToSlice.getMaxZ();
    //TODO: Adding +1 to width fixes overlapping issue but does not seem right.
    float materialHalfWidth = ((SETTINGS.materialThickness / 2) / SETTINGS.scale);
    sketchPath.add(new SketchPoint(maxZ-materialHalfWidth+penetration,0));
    sketchPath.add(new SketchPoint(minZ+materialHalfWidth-penetration,0));
    sketchPath.add(new SketchPoint(minZ+materialHalfWidth-penetration, pLen-penetration));
    sketchPath.add(new SketchPoint(maxZ-materialHalfWidth+penetration, pLen-penetration));

    slicePlane.getSketch().getSketchShapes().add(sketchPath);
    sketchPath.setClosed(true);
   
   
   
   
   
View Full Code Here

              bezierPointLeft.y);

        }
      }

      SketchPath sketchPath = new SketchPath(slicePlane.getSketch());

      for (int i1 = 0; i1 < topLine.size(); i1++) {
        SketchPoint tempP = topLine.get(i1);
        // sktOutline.add(tempVec);
        sketchPath.add(tempP);

        float offsetX = (width / (numSlices - 1)) / 2;

        if (i1 != 0 && i1 != topLine.size() - 1
            && SETTINGS_SKETCH.Draw_Curves)
          sketchPath.addBezier(tempP,
              new Vec2D(tempP.x - offsetX, tempP.y), new Vec2D(
                  tempP.x + offsetX, tempP.y));

      }

      for (int i1 = bottomLine.size() - 1; i1 >= 0; i1--) {
        // sketchPath.add((Vec2D) bottomLine.get(i1));
        SketchPoint tempP = bottomLine.get(i1);
        sketchPath.add(tempP);

        float offsetX = (width / (numSlices - 1)) / 2;

        if (i1 != bottomLine.size() - 1 && i1 != 0
            && !crossSliceSelection.tieToLeg
            && SETTINGS_SKETCH.Draw_Curves)
          sketchPath.addBezier(tempP,
              new Vec2D(tempP.x + offsetX, tempP.y), new Vec2D(
                  tempP.x - offsetX, tempP.y));

      }

      if (controlPointLeft != null) {
        sketchPath
            .addBezier((SketchPoint) bezierPointLeft,controlPointLeft,
                    bezierPointLeft);
        sketchPath.addBezier((SketchPoint) bezierPointRight,
            bezierPointRight,
                controlPointRight);

      }

      // sketchPath.add((Vec2D) bottomLine.get(bottomLine.size()-1));
      // System.out.println(" shape len " + sktOutline.l.size());

      // slicePlane.sketchShapes.sketchOutlines.add(sktOutline);
      // slicePlane.selected = true;
      // slicePlane.sketchShapes.optimize();
      sketchPath.setClosed(true);
     
      slicePlane.getSketch().add(sketchPath);
      slicePlane.getSketch().buildOutline();
      slicePlane.generate();
View Full Code Here

      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) {

                neartestDist = d;
                bottomIntersect = vec2d;
                bottomIntersectX = vec2dX;
              }
            }

           
            /**
             * Lets Fix any intersects that are swapped around
             */
            if ((bottomIntersect != null && topIntersect != null)
                && bottomIntersect.y < topIntersect.y) {
              Vec2D topIntersectTemp = topIntersect.copy();
              Vec2D topIntersectXTemp = topIntersectX.copy();

              topIntersect = bottomIntersect;
              topIntersectX = bottomIntersectX;

              bottomIntersect = topIntersectTemp;
              bottomIntersectX = topIntersectXTemp;

            }

           
            /**
             * Are slats a set height?
             */
            if (crossSliceSelection.getSlatHeight() != 0) {
              bottomIntersect = topIntersect.add(0,
                  crossSliceSelection.getSlatHeight());
              bottomIntersectX = topIntersectX.add(0,
                  crossSliceSelection.getSlatHeight());
            }

            if (SETTINGS.DEBUG) {
              currentPlaneY.debugIntersectionPointsTop
                  .add(topIntersectX);
              currentPlaneY.debugIntersectionPointsBottom
                  .add(bottomIntersectX);

            }

            //if we have found both intersects then add them to the outline
            if (bottomIntersect != null && topIntersect != null) {
              float len = bottomIntersect
                  .distanceTo(topIntersect);

              if (!currentPlaneY.guide) {

                if (crossSliceSelection.flipSide) {
                  Vec2D slotPos = bottomIntersectX.copy();
                  Vec2D dirPerp = new Vec2D(vecDir.x,
                      vecDir.y);
                  dirPerp.rotate((float) (Math.PI / 2));
                  SliceSlot slot = new SliceSlot(slicePlane,
                      slotPos, new Vec2D(
                          -vecDir.x,
                          -vecDir.y),
                      (len / 2f),
                      SETTINGS.materialThickness);
                  slot.setOnEdge(new Vec2D(0, -1));
                  if(crossSliceSelection.getCapType() != CrossSliceSelection.CAP_INSIDE)
                    slot.makesEdge = true;
                  currentPlaneY
                      .getSketch()
                      .getSlots()
                      .add(slot);

                } else {
                  Vec2D slotPos = topIntersectX.copy();
                  Vec2D dirPerp = new Vec2D(vecDir.x,
                      vecDir.y);
                  dirPerp.rotate((float) (Math.PI / 2));
                  SliceSlot slot = new SliceSlot(slicePlane,
                      slotPos,
                      new Vec2D(vecDir.x,
                          vecDir.y),
                      (len / 2f),
                      SETTINGS.materialThickness);
                  slot.setOnEdge(new Vec2D(0, -1));
                  if(crossSliceSelection.getCapType() != CrossSliceSelection.CAP_INSIDE)
                    slot.makesEdge = true;
                  // Switch what side slots are added to
                  currentPlaneY
                      .getSketch()
                      .getSlots()
                      .add(slot);
                }
              }

              Vec2D topSlotintersect = bottomIntersect.copy();
              Vec2D bottomtopSlotintersect = topIntersect.copy();

              if (!currentPlaneY.guide) {

                if (!crossSliceSelection.flipSide) {
                  if (j != 0
                      && j != planesToSlice.getList()
                          .size() - 1){
                    SliceSlot slot = new SliceSlot(
                        currentPlaneY,
                        topSlotintersect,
                        new Vec2D(-1, 0),
                        (len / 2f),
                        SETTINGS.materialThickness);
                    slot.setOnEdge(new Vec2D(0, -1));
                    if(crossSliceSelection.getCapType() != CrossSliceSelection.CAP_INSIDE)
                      slot.makesEdge = true;
                    slicePlane
                        .getSketch()
                        .getSlots()
                        .add(slot);
                  }
                } else {
                  if (j != 0
                      && j != planesToSlice.getList()
                          .size() - 1){
                    SliceSlot slot = new SliceSlot(
                        currentPlaneY,
                        bottomtopSlotintersect,
                        new Vec2D(1, 0),
                        ((len / 2f)),
                        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){

              // add bezier points

              /**
               * BUILD the legs
               *
               * ________
               * |:/  \:|
               * ||    ||
               * --    --
               */
             
              if (crossSliceSelection.tieToLeg) {
                // if(crossSliceSelection.tiedToPlanes.contains(currentPlaneY)){
               
               
                if (crossSliceSelection.legSpline != null
                    && crossSliceSelection.legSpline
                        .getPath() != null
                    && crossSliceSelection.tiedToPlanes.contains(currentPlaneY)) {
                 
                 
                 
                 
                 
                  Vec2D seatBottom = null;

                  if(crossSliceSelection.extendLegSliceToTopOfLeg){
                    seatBottom = new Vec2D(0,0);
                  }else{
                 
                   
                    SketchShapes tempSketchShapes = currentPlaneY.getSketch().getSketchShapes().clone();
                   
                    tempSketchShapes.removeLegs();
                    tempSketchShapes.sketchOutlines.clear();
                    tempSketchShapes.buildOutline();
                   
                    if (tempSketchShapes.sketchOutlines
                        .getOutterOutline() == null)
                      return;
                   
                   
                    SketchShape sktch = tempSketchShapes.sketchOutlines.getOutterOutline().getPath();

                   
                    List<List<Vec2D>> points02 = currentPlaneY.getIntersection(
                        slicePlane, true,
                        sktch);
                   
                   
                    for (int k = 0; k < points02.size(); k++) {
                     
                      Vec2D vec2d = (Vec2D) points02.get(k).get(0);
                      if(seatBottom == null || vec2d.distanceTo(topIntersect) > vec2d.distanceTo(seatBottom) )
                        seatBottom = vec2d;
                     
                    }
           
                 
                   if(seatBottom == null)
                    seatBottom = bottomIntersect;
                 
                  }
                  // this is hard coded so legs are always on
                  // the outside slices!
                  topLine.add(new SketchPoint(topIntersect));


                  //bottomLine.add(new SketchPoint(bottomIntersect));
                  float legWidthBottom = 20;
                  float legWidthTop = 20;
                  SketchSpline legSpline = crossSliceSelection.legSpline;
                  float Yoffset = 0;
                  float yMin = 0;
                 
                  SketchPoint p1 = null, p2, p3, p4;
                  if (legSpline.getPath().size() == 4) {
                    p1 = (SketchPoint) legSpline.getPath()
                        .get(1);
                    p2 = (SketchPoint) legSpline.getPath()
                        .get(2);

                    p3 = (SketchPoint) legSpline.getPath()
                        .get(0);
                    p4 = (SketchPoint) legSpline.getPath()
                        .get(3);

                    legWidthBottom = p1.distanceTo(p2);
                    legWidthTop = p3.distanceTo(p4);
                    Yoffset = 0;
                   
                   
                   
                    Vec2D p5 = GLOBAL.uiTools.getPointOnPlane(legSpline.getCentrePath().get(0), slicePlane.getPlane());
                    Vec2D p6 = GLOBAL.uiTools.getPointOnPlane(legSpline.getCentrePath().get(1), slicePlane.getPlane());

                    //slicePlane.getPlane().getIntersectionWithRay(r);
                    yMin = 29;//Math.min(p5.y,p6.y);
                   


                   
                  }
                 
                  //Get the last intersect
                  //TODO this will get the intersect to the left, whitch is not always desirable
                 
                  if(bottomLine.size() > 0)
                    Yoffset = bottomLine.get(bottomLine.size()-1).y;

                  //TODO: LEG STUFF
                  //Yoffset = legSpline.getCentrePath().get(0).distanceTo(legSpline.getCentrePath().get(1));
                  bottomLine.add(new SketchPoint(
                      bottomIntersect.x
                          - (legWidthTop / 2),
                          seatBottom.y));

                  bottomLine.add(new SketchPoint(
                      bottomIntersect.x
                          - (legWidthBottom / 2),
                      bottomIntersect.y));

                //  bottomLine.add(new SketchPoint(
                //      bottomIntersect.x,
                //      yMin));

                  bottomLine.add(new SketchPoint(
                      bottomIntersect.x
                          + (legWidthBottom / 2),
                      bottomIntersect.y));

                  bottomLine.add(new SketchPoint(
                      bottomIntersect.x
                          + (legWidthTop / 2),
                          seatBottom.y));

                } else {

                  topLine.add(new SketchPoint(topIntersect));
                  bottomLine.add(new SketchPoint(
                      bottomIntersect));

                }

              } else {
                topLine.add(new SketchPoint(topIntersect));
                bottomLine
                    .add(new SketchPoint(bottomIntersect));

              }

            }
          }
        }
      }

     
     
      /**
       * Check what direction our slats are going in and reverse them if they're going in the wrong dir
       */
     
      if(topLine.size() > 0 && ((SketchPoint)topLine.get(0)).x > ((SketchPoint)topLine.get(topLine.size()-1)).x){
        topLine.reverseWinding();
        bottomLine.reverseWinding();
      }
     
      /**
       * Should we generate flat tops?
       *
       */

     
      // now go around the lines we collected and add them to a
      // outline
      Vec2D controlPointLeft = null;
      Vec2D bezierPointLeft = null;

      Vec2D controlPointRight = null;
      Vec2D bezierPointRight = null;

      if (crossSliceSelection.smooth) {
        bottomLine.smoothLeft(SETTINGS_SKETCH.SMOOTH_AMOUNT);
        topLine.smoothRight(SETTINGS_SKETCH.SMOOTH_AMOUNT);
      }
     
     
      if(crossSliceSelection.generateFlushTops){
       
        float materialWidth = SETTINGS.materialThickness/SETTINGS.scale; //TODO: change this so it is more general
        for (int i1 = 0; i1 < topLine.size(); i1++) {
          SketchPoint tempP = topLine.get(i1);
         

         
          SketchPoint pLeft = new SketchPoint(tempP.x+((materialWidth/2)), tempP.y);
          SketchPoint pRight = new SketchPoint(tempP.x-((materialWidth/2)), tempP.y);

          if(tempP.containsBezier()){
            //pLeft.controlPoint1 = tempP.controlPoint1.copy();
           
            pLeft.controlPoint2 = tempP.controlPoint2.copy();
            pRight.controlPoint1 = tempP.controlPoint1.copy();
           
            //pRight.controlPoint2 = tempP.controlPoint2.copy();

          }
          topLine.set(i1,pLeft);
          topLine.add(i1, pRight);
          i1++;

        }
       
       
        if(crossSliceSelection.type != CrossSliceSelection.LEG){
         
         
         
          for (int i1 = 0; i1 < bottomLine.size(); i1++) {
            SketchPoint tempP = bottomLine.get(i1);
            SketchPoint pLeft = new SketchPoint(tempP.x-(materialWidth/2), tempP.y);
            SketchPoint pRight = new SketchPoint(tempP.x+(materialWidth/2), tempP.y);

            if(tempP.containsBezier()){
              //pLeft.controlPoint1 = tempP.controlPoint1.copy();
              pLeft.controlPoint2 = tempP.controlPoint2.copy();

              pRight.controlPoint1 = tempP.controlPoint1.copy();
              //pRight.controlPoint2 = tempP.controlPoint2.copy();

            }
            bottomLine.set(i1,pRight);
            bottomLine.add(i1, pLeft);
            i1++;

          }
         
        }
       
       
       
      }
     
     

      /**
       * <pre>
       * CAPPING
       * |-----------|
       * |-----------|
       * </pre>
       */

      SketchPath sketchPath = new SketchPath(slicePlane.getSketch());

      if (crossSliceSelection.getCapType() == CrossSliceSelection.CAP_ROUND_SQUARE) {
        // now change the line caping
        if (bottomLine.size() > 1) {

          float cornerRad = crossSliceSelection.cornerRadius;
          bottomLine.add(0, (SketchPoint) bottomLine.get(0).clone());
          bottomLine.add((SketchPoint) bottomLine.get(
              bottomLine.size() - 1).clone());

          bottomLine.get(0).addSelf(0, -cornerRad);
          bottomLine.get(1).addSelf(cornerRad, 0);
          bottomLine.get(0).controlPoint1 = new Vec2D(
              bottomLine.get(0).x, bottomLine.get(0).y
                  + cornerRad);
          bottomLine.get(0).controlPoint2 = bottomLine.get(0).copy();

          bottomLine.get(bottomLine.size() - 1)
              .addSelf(0, -cornerRad);
          bottomLine.get(bottomLine.size() - 2)
              .addSelf(-cornerRad, 0);
          bottomLine.get(bottomLine.size() - 1).controlPoint2 = new Vec2D(
              bottomLine.get(bottomLine.size() - 1).x,
              bottomLine.get(bottomLine.size() - 1).y + cornerRad);
          bottomLine.get(bottomLine.size() - 1).controlPoint1 = bottomLine
              .get(bottomLine.size() - 1).copy();

          topLine.add(0, (SketchPoint) topLine.get(0).clone());
          topLine.add((SketchPoint) topLine.get(topLine.size() - 1)
              .clone());

          topLine.get(0).addSelf(0, cornerRad);
          topLine.get(1).addSelf(cornerRad, 0);
          topLine.get(0).controlPoint2 = new Vec2D(topLine.get(0).x,
              topLine.get(0).y - cornerRad);
          topLine.get(0).controlPoint1 = topLine.get(0).copy();

          topLine.get(topLine.size() - 1).addSelf(0, cornerRad);
          topLine.get(topLine.size() - 2).addSelf(-cornerRad, 0);
          topLine.get(topLine.size() - 1).controlPoint1 = new Vec2D(
              topLine.get(topLine.size() - 1).x,
              topLine.get(topLine.size() - 1).y - cornerRad);
          topLine.get(topLine.size() - 1).controlPoint2 = topLine
              .get(topLine.size() - 1).copy();

          for (int i1 = 0; i1 < topLine.size(); i1++) {
            SketchPoint tempP = topLine.get(i1);
            sketchPath.add(tempP);
           
          }

          for (int i1 = bottomLine.size() - 1; i1 >= 0; i1--) {
            SketchPoint tempP = bottomLine.get(i1);
            sketchPath.add(tempP);
           
          }

        }
      }

      // adds a curve to the bottom line
      if (crossSliceSelection.getCapType() == CrossSliceSelection.CAP_CURVE) {
        // now change the line capping
        if (bottomLine.size() > 1) {

          controlPointRight = bottomLine.get(0);
          bezierPointRight = bottomLine.get(1);

          controlPointLeft = bottomLine.get(bottomLine.size() - 1);
          bezierPointLeft = bottomLine.get(bottomLine.size() - 2);
          bottomLine.remove(0);
          bottomLine.remove(bottomLine.size() - 1);

          if (crossSliceSelection.tieToLeg) {
            controlPointRight = new Vec2D(bezierPointRight.x - 15,
                bezierPointRight.y);
            controlPointLeft = new Vec2D(bezierPointLeft.x + 15,
                bezierPointLeft.y);

          }
        }

        for (int i1 = 0; i1 < topLine.size(); i1++) {
          SketchPoint tempP = topLine.get(i1);
          sketchPath.add(tempP);

          float offsetX = (width / (numSlices - 1)) / 2;

          if (i1 != 0 && i1 != topLine.size() - 1
              && SETTINGS_SKETCH.Draw_Curves)
            sketchPath.addBezier(tempP,
                new Vec2D(tempP.x - offsetX, tempP.y),
                new Vec2D(tempP.x + offsetX, tempP.y));

        }

        for (int i1 = bottomLine.size() - 1; i1 >= 0; i1--) {
          SketchPoint tempP = bottomLine.get(i1);
          sketchPath.add(tempP);

          float offsetX = (width / (numSlices - 1)) / 2;

          if (i1 != bottomLine.size() - 1 && i1 != 0
              && !crossSliceSelection.tieToLeg
              && SETTINGS_SKETCH.Draw_Curves)
            sketchPath.addBezier(tempP,
                new Vec2D(tempP.x + offsetX, tempP.y),
                new Vec2D(tempP.x - offsetX, tempP.y));

        }

        if (controlPointLeft != null) {
          sketchPath.addBezier((SketchPoint) bezierPointLeft,
              controlPointLeft,
                  bezierPointLeft);
          sketchPath.addBezier((SketchPoint) bezierPointRight,
              bezierPointRight,
                  controlPointRight);

        }

      }

      if (crossSliceSelection.getCapType() == CrossSliceSelection.CAP_BUTT
          || crossSliceSelection.getCapType() == CrossSliceSelection.CAP_INSIDE) {

        bottomLine.get(0).removeBezier();
        bottomLine.get(bottomLine.size() - 1).removeBezier();

        topLine.get(0).removeBezier();
        topLine.get(topLine.size() - 1).removeBezier();

        for (int i1 = 0; i1 < topLine.size(); i1++) {
          SketchPoint tempP = topLine.get(i1);
          sketchPath.add(tempP);

        }
        for (int i1 = bottomLine.size() - 1; i1 >= 0; i1--) {
          SketchPoint tempP = bottomLine.get(i1);
          sketchPath.add(tempP);
        }

      }

      sketchPath.setClosed(true);

      slicePlane.getSketch().add(sketchPath);
      slicePlane.getSketch().buildOutline();
      slicePlane.generate();

View Full Code Here

   
    this.setSketch(parentSketch);
    this.getSketch().setOnSlicePlane(this);
    this.setPlane(plane);
    coverPath = new SketchPath(getSketch());
    //this.build();
    this.select();

    //  GLOBAL.undo.addOperation(new UndoAction(this, UndoAction.ADD_PLANE));
  }
View Full Code Here

      }

      if (object instanceof SketchPath) {
       
        //TODO: we need to make the crop to shop the correct one on each plane.
        SketchPath spline = (SketchPath) object;
        ShetchShapesIntersect.add(spline);
      }

    } else {
      SketchOutline outline = this.getSketch().getSketchShapes().sketchOutlines
          .getOutterOutline();

      for (int o = 0; o < this.getSketch().getSketchShapes().sketchOutlines
          .getList().size(); o++) {
        SketchPath outline2 = this.getSketch().getSketchShapes().sketchOutlines
            .getList().get(o).getPath();
        ShetchShapesIntersect.add(outline2);

      }

      //ShetchShapesIntersect.add(this.getSketch().getSketchShapes().sketchOutlines.getOutterOutline().getPath());
      //path = outline.getPath();
    }

    if (ShetchShapesIntersect.size() == 0)
      return null;

    for (int sh = 0; sh < ShetchShapesIntersect.size(); sh++) {
      SketchPath path = (SketchPath) ShetchShapesIntersect.get(sh);

      for (int i = 1; i <= path.size(); i++) {
        Vec3D p1 = null;
        Vec3D p2 = null;

        if (i != 0) {
          p1 = this.getWorldPos((Vec2D) path.get(i - 1));
        } else {
          p1 = this.getWorldPos((Vec2D) path.get(path.size() - 1));
        }

        if (i != path.size()) {
          p2 = this.getWorldPos((Vec2D) path.get(i));
        } else {
          p2 = this.getWorldPos((Vec2D) path.get(0));
        }
        //

        // if one point is on one side of the plane and the other point is
        // on the other side !

        if (slicePlane.getPlane().classifyPoint(p1) != slicePlane
            .getPlane().classifyPoint(p2)) {
          //we found a intersect
          SketchPoint vec2D1 = null;

          if (i != 0) {
            vec2D1 = (SketchPoint) path.get(i - 1);
          } else {
            vec2D1 = (SketchPoint) path.get(path.size() - 1);
          }

          SketchPoint vec2D2 = null;
          if (i < path.size()) {
            vec2D2 = (SketchPoint) path.get(i);
          } else {
            vec2D2 = (SketchPoint) path.get(0);
          }

          if (vec2D1 == null || vec2D2 == null)
            break;
View Full Code Here

TOP

Related Classes of cc.sketchchair.sketch.SketchPath

Copyright © 2015 www.massapicom. All rights reserved.
All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.