poc-igeom-karla/src/app/components/intersection-component/drawers/intersection-drawer.js

/*
 * iGeom by LInE
 * Provides intersetion point to Geometric Objects (GO)
 * www.matematica.br/igeom
 * ./app/components/intersection-component/drawers/intersection-drawer.js
 * @calledby 
 * @version 2020/11/02: Implemented Line instersection.
 */

import { PointDrawer } from "../../point-component/drawers/point-drawer";
import { ELEMENTS_CLASS } from "../../../core/enums/elements-class-enum";
import { Drawer } from "../../../core/drawers/drawer";
import { app as App } from "../../../app";
import { objects } from "../../../core/application/objects";
import { DrawerAggregator } from "../../../core/drawers/drawer-aggregator";
import { intersectionService } from "../services/intersection-service";

export class IntersectionDrawer extends Drawer {

  static FIRST_OBJECT_STATE () {
    return "FIRST_OBJECT";
    }

  static SECOND_OBJECT_STATE () {
    return "SECOND_OBJECTf";
    }

  constructor () {
    super();
    this.aggregatorA;
    this.aggregatorB;
    this.label;
    this.states = [IntersectionDrawer.FIRST_OBJECT_STATE, IntersectionDrawer.SECOND_OBJECT_STATE];
    this.intersections = [];
    this.pointDrawer = new PointDrawer();
    super.setElementClass(ELEMENTS_CLASS.INTERSECTION_POINT);
    }

  // @calledby ./app/core/drawers/stage.js! draw (e): this.drawer.draw(e);
  draw (e) {
    if (e != undefined && e.attrs != undefined) {
      this.aggregatorA = this.getObjectAggregatorByGenericObject(e.attrs.genericObject.r);
      this.aggregatorB = this.getObjectAggregatorByGenericObject(e.attrs.genericObject.s);
      this.drawByIntersectionPoints([e.attrs.genericObject]);
      return;
      }
    if (e == undefined || !this.isValidObject(e.target)) return;

    const selectedTool = App.getSelectedTool();
    if (selectedTool != undefined && selectedTool.drawer != undefined && selectedTool.drawer.elementClass == ELEMENTS_CLASS.INTERSECTION_POINT) {
      if (this.state == undefined || this.state == IntersectionDrawer.FIRST_OBJECT_STATE) {
        this.setFirstObject(e.target);
        this.setState(IntersectionDrawer.SECOND_OBJECT_STATE);
        }
      else if (this.state == IntersectionDrawer.SECOND_OBJECT_STATE) {
        this.setSecondObject(e.target);
        this.drawPoint();
        this.reset();
        // this.clear();
        }
      }
    }

  setFirstObject (konvaObject) {
    const aggregator = this.getObjectAggregator(konvaObject);
    this.aggregatorA = aggregator;
    }

  setSecondObject (konvaObject) {
    const aggregator = this.getObjectAggregator(konvaObject);
    this.aggregatorB = aggregator;
    }

  getObjectAggregator (konvaObject) {
    return objects.getByKonvaObject(konvaObject)[0];
    }

  getObjectAggregatorByGenericObject (genericObject) {
    return objects.getByGenericObject(genericObject)[0];
    }

  // Avoid to create intersection between lines/segments when some defining point is the intersection
  // Return true <=> need a new point
  alreadyHasIntersection (og1, og2, str_a1, str_a2) {
    if ((og1.elementClass==ELEMENTS_CLASS.LINE || og1.elementClass==ELEMENTS_CLASS.LINE_SEGMENT) &&
        (og2.elementClass==ELEMENTS_CLASS.LINE || og2.elementClass==ELEMENTS_CLASS.LINE_SEGMENT)) {
      // Try to avoid redundant point
      //D var aux = " ELEMENTS_CLASS.LINE=" + ELEMENTS_CLASS.LINE + ", ";
      if (og1.pointA==og2.pointA || og1.pointA==og2.pointB || og1.pointB==og2.pointA || og1.pointB==og2.pointB) {
        var aux2 = " "+og1.pointA+","+og1.pointB+";"+og2.pointA+","+og2.pointB+" ";
        console.log("intersection-drawer.js!alreadyHasIntersection(): existing intersection, nothing to be done: " + str_a1 + " , " + str_a2 + ", " + aux2);
        //TODO need to become visible? "og1.visible = true;" or "og2.visible = true;"
        return true;
        }
      }
    return false;
    }


  // Used to create new intersection point
  //@calledby this.draw()
  drawPoint () {
    const og1 = this.aggregatorA.genericObject, og2 = this.aggregatorB.genericObject;
    const str_a1 = "og1=(" + og1.elementClass + ",id=" + og1.id + ")"; //D genericObject
    const str_a2 = "og2=(" + og2.elementClass + ",id=" + og2.id + ")"; //D
    if (this.alreadyHasIntersection(og1,og2,str_a1,str_a2)) return;
    console.log("intersection-drawer.js!drawPoint(): create intersection between " + str_a1 + " , " + str_a2);
    const intersectionOg1Og2 = og1.getIntersection(og2);
    const intersectionPoints = intersectionService.addIntersections(intersectionOg1Og2);
    this.drawByIntersectionPoints(intersectionPoints);
    }

  drawByIntersectionPoints (intersectionPoints) {
    for (let index = 0; index < intersectionPoints.length; index++) {
      const intersectionPoint = intersectionPoints[index];
      intersectionPoint.update();
      // if (!intersectionPoint.visible) return;
      const point = PointDrawer.drawPoint(intersectionPoint, true, false, true);
      const aggregator = new DrawerAggregator(this, intersectionPoint, point.konvaObject, ELEMENTS_CLASS.INTERSECTION_POINT);
      super.addAggregator(aggregator);
      this.aggregatorB.addAggregator(aggregator);
      this.aggregatorA.addAggregator(aggregator);
      }
    }

  isValidObject (konvaObject) {
    switch (konvaObject.attrs.class) {
      case ELEMENTS_CLASS.LINE:
        return true;
      case ELEMENTS_CLASS.LINE_SEGMENT:
        return true;
      case ELEMENTS_CLASS.CIRCUMFERENCE:
        return true;
        case ELEMENTS_CLASS.MIDDLE_POINT:
          return true;
      default:
        return false;
      }
    }

  update (aggregator, e) {
    aggregator.genericObject.update(aggregator, e);

    if (!aggregator.genericObject.visible || aggregator.genericObject.posX == Number.MAX_SAFE_INTEGER) {
      if (aggregator.visible) {
        aggregator.konvaObject.hide();
        aggregator.aggregators.forEach(a => {
          a.visible = false;
          a.konvaObject.hide();
        });
        this.batchDraw();
        }
      aggregator.visible = false;
      return;
      }
    //todo: konva objects
    aggregator.konvaObject.children[0].x(aggregator.genericObject.posX + 10);
    aggregator.konvaObject.children[0].y(aggregator.genericObject.posY - 10);

    aggregator.konvaObject.children[1].x(aggregator.genericObject.posX);
    aggregator.konvaObject.children[1].y(aggregator.genericObject.posY);

    if (!aggregator.visible || aggregator.genericObject.posX == Number.MAX_SAFE_INTEGER) {
      aggregator.genericObject.visible = true;
      aggregator.konvaObject.show();
      aggregator.aggregators.forEach(a => {
        a.visible = true;
        a.konvaObject.show();
        });
      aggregator.visible = true;
      }
    this.batchDraw();
    }

  reset () {
    this.aggregatorA = undefined;
    this.aggregatorB = undefined;
    this.setState(undefined);
    }

  } // export class IntersectionDrawer extends Drawer