kitchen-simulator 5.0.0-test.4 → 5.0.0-test.5

package/src/class/layer.js

@@ -1,926 +0,0 @@
-import { List } from 'immutable';
-import { Project, Area, Line, Hole, Item, Vertex } from './export';
-import { GraphInnerCycles, GeometryUtils, IDBroker } from '../utils/export';
-import { Layer as LayerModel } from '../models';
-import { isEmpty } from '../utils/helper';
-
-const sameSet = (set1, set2) =>
-  set1.size === set2.size && set1.isSuperset(set2) && set1.isSubset(set2);
-const sameDirection = (list1, list2) => {
-  if (!sameSet(list1, list2)) return false;
-  if (list1.size < 3) return true;
-  let l0 = list1.get(0);
-  let l1 = list1.get(1);
-  let i0 = list2.indexOf(l0);
-  let i1 = list2.indexOf(l1);
-  return (i1 - i0 - 1) % list1.size == 0;
-};
-
-class Layer {
-  static create(state, name, altitude) {
-    let layerID = IDBroker.acquireID();
-    name = name || `layer ${layerID}`;
-    altitude = altitude || 0;
-
-    let layer = new LayerModel({ id: layerID, name, altitude });
-
-    state = state.setIn(['scene', 'selectedLayer'], layerID);
-    state = state.setIn(['scene', 'layers', layerID], layer);
-
-    return { updatedState: state };
-  }
-
-  static select(state, layerID) {
-    if (!state.get('alterate')) state = Project.unselectAll(state).updatedState;
-    state = state.setIn(['scene', 'selectedLayer'], layerID);
-
-    return { updatedState: state };
-  }
-
-  static selectAll(state, layerID) {
-    if (!state.get('alterate')) state = Project.unselectAll(state).updatedState;
-    state = state.setIn(['scene', 'selectedLayer'], layerID);
-    let layer = state.scene.layers.get(layerID);
-    layer.items.forEach(data => {
-      state = Layer.selectElement(
-        state,
-        layerID,
-        'items',
-        data.id
-      ).updatedState;
-    });
-    layer.lines.forEach(data => {
-      state = Layer.selectElement(
-        state,
-        layerID,
-        'lines',
-        data.id
-      ).updatedState;
-    });
-    layer.holes.forEach(data => {
-      state = Layer.selectElement(
-        state,
-        layerID,
-        'holes',
-        data.id
-      ).updatedState;
-    });
-    layer.areas.forEach(data => {
-      state = Layer.selectElement(
-        state,
-        layerID,
-        'areas',
-        data.id
-      ).updatedState;
-    });
-    layer.vertices.forEach(data => {
-      state = Layer.selectElement(
-        state,
-        layerID,
-        'vertices',
-        data.id
-      ).updatedState;
-    });
-
-    return { updatedState: state };
-  }
-
-  static selectElement(state, layerID, elementPrototype, elementID) {
-    state = state.setIn(
-      ['scene', 'layers', layerID, elementPrototype, elementID, 'selected'],
-      true
-    );
-    state = state.updateIn(
-      ['scene', 'layers', layerID, 'selected', elementPrototype],
-      elems => elems.push(elementID)
-    );
-
-    return { updatedState: state };
-  }
-
-  static unselect(state, layerID, elementPrototype, elementID) {
-    state = state.setIn(
-      ['scene', 'layers', layerID, elementPrototype, elementID, 'selected'],
-      false
-    );
-    state = state.updateIn(
-      ['scene', 'layers', layerID, 'selected', elementPrototype],
-      elems => elems.filter(el => el.id === elementID)
-    );
-    return { updatedState: state };
-  }
-
-  static updateMovingState(state, showflag) {
-    let { scene } = state;
-
-    state = state.merge({
-      scene: scene.mergeIn(['showfg'], showflag)
-    });
-    return { updatedState: state };
-  }
-
-  static unselectAll(state, layerID) {
-    let { lines, holes, items, areas } = state.getIn([
-      'scene',
-      'layers',
-      layerID
-    ]);
-
-    if (lines)
-      lines.forEach(line => {
-        state = Line.unselect(state, layerID, line.id).updatedState;
-      });
-    if (holes)
-      holes.forEach(hole => {
-        state = Hole.unselect(state, layerID, hole.id).updatedState;
-      });
-    if (items)
-      items.forEach(item => {
-        state = Item.unselect(state, layerID, item.id).updatedState;
-      });
-    if (areas)
-      areas.forEach(area => {
-        state = Area.unselect(state, layerID, area.id).updatedState;
-      });
-
-    return { updatedState: state };
-  }
-
-  static setInitialDoorStyle(state, doorStyle, oStyle) {
-    state = state.merge({
-      doorStyle: doorStyle
-    });
-    let { scene } = state;
-    let layerID = scene.get('selectedLayer');
-    let selectedLayer = scene.layers.get(layerID);
-    selectedLayer = selectedLayer.setIn(['doorStyle'], doorStyle);
-    state = state.merge({
-      scene: scene.setIn(['layers', layerID], selectedLayer)
-    });
-    return { updatedState: state };
-  }
-
-  static setProperties(state, layerID, properties) {
-    state = state.mergeIn(['scene', 'layers', layerID], properties);
-    state = state.updateIn(['scene', 'layers'], layers =>
-      layers.sort((a, b) =>
-        a.altitude !== b.altitude ? a.altitude - b.altitude : a.order - b.order
-      )
-    );
-
-    return { updatedState: state };
-  }
-
-  static remove(state, layerID) {
-    state = state.removeIn(['scene', 'layers', layerID]);
-
-    state = state.setIn(
-      ['scene', 'selectedLayer'],
-      state.scene.selectedLayer !== layerID
-        ? state.scene.selectedLayer
-        : state.scene.layers.first().id
-    );
-
-    return { updatedState: state };
-  }
-
-  static removeElement(state, layerID, elementPrototype, elementID) {
-    state = state.deleteIn([
-      'scene',
-      'layers',
-      layerID,
-      elementPrototype,
-      elementID
-    ]);
-
-    return { updatedState: state };
-  }
-
-  static lineInterior(
-    relatedLine,
-    line,
-    changeLines,
-    vertices,
-    allLines,
-    checkLines
-  ) {
-    if (
-      line.vertices[1] === relatedLine.vertices[1] ||
-      line.vertices[0] === relatedLine.vertices[0]
-    ) {
-      let tmp = line.vertices[0];
-      line.vertices[0] = line.vertices[1];
-      line.vertices[1] = tmp;
-      changeLines.push(line);
-    }
-    checkLines.push(relatedLine);
-    checkLines.push(line);
-    let relatedLines = [];
-    GeometryUtils.getRelatedLines(relatedLines, line, vertices, allLines);
-    let delflag = false;
-    if (isEmpty(allLines[line.id])) {
-      delflag = true;
-    }
-    if (relatedLines.length > 1) {
-      for (let i = 0; i < relatedLines.length; i++) {
-        if (
-          !changeLines.some(line => line.id === relatedLines[i].id) &&
-          !checkLines.some(cline => cline.id === relatedLines[i].id)
-        ) {
-          let tline = delflag ? relatedLine : line;
-          this.lineInterior(
-            tline,
-            relatedLines[i],
-            changeLines,
-            vertices,
-            allLines,
-            checkLines
-          );
-        }
-      }
-    } else return;
-  }
-
-  static interiorsurfacedetect(
-    state,
-    drawingLine,
-    vertices,
-    allLineArray,
-    layerID
-  ) {
-    let relatedLines = [];
-    let allLines = allLineArray.toJS();
-    GeometryUtils.getRelatedLines(
-      relatedLines,
-      drawingLine,
-      vertices,
-      allLines
-    );
-    if (isEmpty(relatedLines)) {
-      return { updatedState: state };
-    }
-    let changeLines = [];
-    let checkLines = [];
-    this.lineInterior(
-      relatedLines[0],
-      drawingLine,
-      changeLines,
-      vertices,
-      allLines,
-      checkLines
-    );
-    for (let i = 0; i < changeLines.length; i++) {
-      // if (changeLines[i].vertices.length === 2)
-      if (!isEmpty(allLines[changeLines[i].id])) {
-        state = state.mergeIn(
-          ['scene', 'layers', layerID, 'lines', changeLines[i].id, 'vertices'],
-          changeLines[i].vertices
-        );
-      }
-    }
-    // determine the interior surface
-    let alltriangles = [];
-    let interiorLines = state.getIn(['scene', 'layers', layerID, 'lines']);
-    let tallLines = interiorLines.toJS();
-    let tallLinesArray = interiorLines.toArray();
-    let reverseLines = [];
-    tallLinesArray.forEach(tline => {
-      let line = tline.toJS();
-      let relatedLines = [];
-      GeometryUtils.getRelatedLines(relatedLines, line, vertices, tallLines);
-      relatedLines.forEach(relLine => {
-        if (relLine.vertices[0] === line.vertices[1]) {
-          if (
-            !reverseLines.some(reverseLine => reverseLine.id === relLine.id)
-          ) {
-            reverseLines.push(relLine);
-          }
-          if (!reverseLines.some(reverseLine => reverseLine.id === line.id)) {
-            reverseLines.push(line);
-          }
-          // get the three points of triangle
-          let x1 = vertices[line.vertices[0]].x;
-          let y1 = vertices[line.vertices[0]].y;
-          let x2 = vertices[line.vertices[1]].x;
-          let y2 = vertices[line.vertices[1]].y;
-          let x3 = vertices[relLine.vertices[1]].x;
-          let y3 = vertices[relLine.vertices[1]].y;
-          // calculate the area of triangle
-          let triArea =
-            Math.abs(
-              (y1 + y3) * (x3 - x1) -
-                (y1 + y2) * (x2 - x1) -
-                (y3 + y2) * (x3 - x2)
-            ) / 2;
-          let triangle = {
-            points: [
-              {
-                x: x1,
-                y: y1
-              },
-              {
-                x: x2,
-                y: y2
-              },
-              {
-                x: x3,
-                y: y3
-              }
-            ],
-            area: triArea
-          };
-          // determine the + or - symbol of triangle
-          let area = 0;
-          for (let i = 0; i < 3; i++) {
-            let j = (i + 1) % 3;
-            area += triangle.points[i].x * triangle.points[j].y;
-            area -= triangle.points[j].x * triangle.points[i].y;
-          }
-          if (area > 0) {
-            triangle.area = -triangle.area;
-          }
-          alltriangles.push(triangle);
-        }
-      });
-    });
-    let reverse = false;
-    let allSum = 0;
-    alltriangles.forEach(triangle => {
-      allSum += triangle.area;
-    });
-    // if all sum of triangle's area is smaller than zero, all walls have to be inverted.
-    if (allSum >= 0) {
-      reverse = false;
-    } else reverse = true;
-    if (reverse) {
-      reverseLines.forEach(line => {
-        let tmp = line.vertices[0];
-        line.vertices[0] = line.vertices[1];
-        line.vertices[1] = tmp;
-        state = state.mergeIn(
-          ['scene', 'layers', layerID, 'lines', line.id, 'vertices'],
-          line.vertices
-        );
-      });
-    }
-    return { updatedState: state };
-  }
-
-  static detectAndUpdateAreas(state, layerID, drawingInfor) {
-    let verticesArray = []; //array with vertices coords
-    let linesArray;
-    let virtualArray = []; //array with edges
-
-    let vertexID_to_verticesArrayIndex = {};
-    let verticesArrayIndex_to_vertexID = {};
-
-    state.getIn(['scene', 'layers', layerID, 'vertices']).forEach(vertex => {
-      let verticesCount = verticesArray.push([vertex.x, vertex.y]);
-      let latestVertexIndex = verticesCount - 1;
-      vertexID_to_verticesArrayIndex[vertex.id] = latestVertexIndex;
-      verticesArrayIndex_to_vertexID[latestVertexIndex] = vertex.id;
-    });
-
-    let vertexCount = verticesArray.length;
-    let vitual = {};
-
-    linesArray = state
-      .getIn(['scene', 'layers', layerID, 'lines'])
-      .map(line =>
-        line.vertices
-          .map(vertexID => vertexID_to_verticesArrayIndex[vertexID])
-          .toArray()
-      );
-
-    //open line
-    // if (vertexCount > 1 && !linesArray.some(line => (line[0]==0 && line[1]==vertexCount-1) || (line[1]==0 && line[0]==vertexCount-1))) {
-    //   linesArray = linesArray.set(IDBroker.acquireID(),  [0, vertexCount-1]);
-    // }
-    let innerCyclesByVerticesArrayIndex = GraphInnerCycles.calculateInnerCycles(
-      verticesArray,
-      linesArray
-    );
-
-    let innerCyclesByVerticesID = new List(innerCyclesByVerticesArrayIndex).map(
-      cycle =>
-        new List(
-          cycle.map(vertexIndex => verticesArrayIndex_to_vertexID[vertexIndex])
-        )
-    );
-    // All area vertices should be ordered in counterclockwise order
-    innerCyclesByVerticesID = innerCyclesByVerticesID.map(area =>
-      GraphInnerCycles.isClockWiseOrder(
-        area.map(vertexID =>
-          state.getIn(['scene', 'layers', layerID, 'vertices', vertexID])
-        )
-      )
-        ? area.reverse()
-        : area
-    );
-    let areaIDs = [];
-
-    //remove areas
-    state.getIn(['scene', 'layers', layerID, 'areas']).forEach(area => {
-      let areaInUse = innerCyclesByVerticesID.some(vertices =>
-        sameDirection(vertices, area.vertices)
-      );
-      if (!areaInUse) {
-        state = Area.remove(state, layerID, area.id).updatedState;
-      }
-    });
-
-    //add new areas
-    innerCyclesByVerticesID.forEach((cycle, ind) => {
-      let areaInUse = state
-        .getIn(['scene', 'layers', layerID, 'areas'])
-        .find(area => sameDirection(area.vertices, cycle));
-
-      if (areaInUse) {
-        areaIDs[ind] = areaInUse.id;
-        state = state.setIn(
-          ['scene', 'layers', layerID, 'areas', areaIDs[ind], 'holes'],
-          new List()
-        );
-      } else {
-        let areaVerticesCoords = cycle.map(vertexID =>
-          state.getIn(['scene', 'layers', layerID, 'vertices', vertexID])
-        );
-        let resultAdd = Area.add(
-          state,
-          layerID,
-          'area',
-          areaVerticesCoords,
-          state.catalog
-        );
-
-        areaIDs[ind] = resultAdd.area.id;
-        state = resultAdd.updatedState;
-      }
-    });
-
-    // Build a relationship between areas and their coordinates
-    let verticesCoordsForArea = areaIDs.map(id => {
-      let vertices = state
-        .getIn(['scene', 'layers', layerID, 'areas', id])
-        .vertices.map(vertexID => {
-          let { x, y } = state.getIn([
-            'scene',
-            'layers',
-            layerID,
-            'vertices',
-            vertexID
-          ]);
-          return new List([x, y]);
-        });
-      return { id, vertices };
-    });
-
-    // Find all holes for an area
-    let i, j;
-    for (i = 0; i < verticesCoordsForArea.length; i++) {
-      let holesList = new List(); // The holes for this area
-      let areaVerticesList = verticesCoordsForArea[i].vertices
-        .flatten()
-        .toArray();
-      for (j = 0; j < verticesCoordsForArea.length; j++) {
-        if (i !== j) {
-          let isHole = GeometryUtils.ContainsPoint(
-            areaVerticesList,
-            verticesCoordsForArea[j].vertices.get(0).get(0),
-            verticesCoordsForArea[j].vertices.get(0).get(1)
-          );
-          if (isHole) {
-            holesList = holesList.push(verticesCoordsForArea[j].id);
-          }
-        }
-      }
-      state = state.setIn(
-        [
-          'scene',
-          'layers',
-          layerID,
-          'areas',
-          verticesCoordsForArea[i].id,
-          'holes'
-        ],
-        holesList
-      );
-    }
-
-    // Remove holes which are already holes for other areas
-    areaIDs.forEach(areaID => {
-      let doubleHoles = new Set();
-      let areaHoles = state.getIn([
-        'scene',
-        'layers',
-        layerID,
-        'areas',
-        areaID,
-        'holes'
-      ]);
-      areaHoles.forEach(areaHoleID => {
-        let holesOfholes = state.getIn([
-          'scene',
-          'layers',
-          layerID,
-          'areas',
-          areaHoleID,
-          'holes'
-        ]);
-        holesOfholes.forEach(holeID => {
-          if (areaHoles.indexOf(holeID) !== -1) doubleHoles.add(holeID);
-        });
-      });
-      doubleHoles.forEach(doubleHoleID => {
-        areaHoles = areaHoles.remove(areaHoles.indexOf(doubleHoleID));
-      });
-      state = state.setIn(
-        ['scene', 'layers', layerID, 'areas', areaID, 'holes'],
-        areaHoles
-      );
-    });
-
-    // update direction of lines surrounding area
-    let layer = state.getIn(['scene', 'layers', layerID]);
-    let allAreaLines = GeometryUtils.getAllAreaLines(layer);
-    // check whether the room is colsed. in this case, the allAreaLines have some values and if doesn't close, this value has nothing.
-    layer.lines.forEach(line => {
-      allAreaLines.some(l => {
-        if (line.vertices.get(0) == l[0] && line.vertices.get(1) == l[1]) {
-          state = state.setIn(
-            ['scene', 'layers', layerID, 'lines', line.id, 'vertices', 0],
-            l[1]
-          );
-          state = state.setIn(
-            ['scene', 'layers', layerID, 'lines', line.id, 'vertices', 1],
-            l[0]
-          );
-          return true;
-        } else if (
-          line.vertices.get(1) == l[0] &&
-          line.vertices.get(0) == l[1]
-        ) {
-          return true;
-        } else {
-          return false;
-        }
-      });
-    });
-
-    //
-    let separatedLine = [];
-    let allLinesArray = state.getIn(['scene', 'layers', layerID, 'lines']);
-    allLinesArray.forEach(line => {
-      let isAreaLine = false;
-      isAreaLine = allAreaLines.some(areaLine => {
-        if (
-          (areaLine[0] == line.vertices.get(0) &&
-            areaLine[1] == line.vertices.get(1)) ||
-          (areaLine[0] == line.vertices.get(1) &&
-            areaLine[1] == line.vertices.get(0))
-        )
-          return true;
-      });
-      // console.log(
-      //   'Layer_Vertices',
-      //   layer.vertices.get(line.vertices.get(0)).toJS()
-      // );
-      if (!isAreaLine) {
-        if (
-          !(
-            GeometryUtils.isPointInArea(
-              GeometryUtils.getAllArea(layer),
-              layer.vertices.get(line.vertices.get(0))
-            ) &&
-            GeometryUtils.isPointInArea(
-              GeometryUtils.getAllArea(layer),
-              layer.vertices.get(line.vertices.get(1))
-            )
-          )
-        ) {
-          separatedLine.push(line);
-        }
-      }
-    });
-    let separatedLineCnt = separatedLine.length;
-
-    if (separatedLineCnt == 1) {
-      separatedLine.forEach(line => {
-        let ptArray = [],
-          pt3 = [],
-          pt4 = [];
-        ptArray.push(
-          verticesArray[vertexID_to_verticesArrayIndex[line.vertices.get(0)]]
-        );
-        ptArray.push(
-          verticesArray[vertexID_to_verticesArrayIndex[line.vertices.get(1)]]
-        );
-        pt3.push(ptArray[1][1] - ptArray[0][1] + ptArray[1][0]);
-        pt3.push(ptArray[0][0] - ptArray[1][0] + ptArray[1][1]);
-        ptArray.push(pt3);
-        pt4.push(ptArray[0][0] + ptArray[2][0] - ptArray[1][0]);
-        pt4.push(ptArray[0][1] + ptArray[2][1] - ptArray[1][1]);
-        ptArray.push(pt4);
-        let pointArray = [];
-        ptArray.forEach(pt => {
-          let point = { x: pt[0], y: pt[1] };
-          pointArray.push(point);
-        });
-        pointArray.reverse();
-        let resultAdd = Area.add(
-          state,
-          layerID,
-          'area',
-          pointArray,
-          state.catalog
-        );
-        state = resultAdd.updatedState;
-      });
-    } else if (separatedLineCnt > 1) {
-      let ptXArray = [],
-        ptYArray = [],
-        ptXMin,
-        ptXMax,
-        ptYMin,
-        ptYMAX;
-      separatedLine.forEach(line => {
-        ptXArray.push(
-          verticesArray[vertexID_to_verticesArrayIndex[line.vertices.get(0)]][0]
-        );
-        ptXArray.push(
-          verticesArray[vertexID_to_verticesArrayIndex[line.vertices.get(1)]][0]
-        );
-        ptYArray.push(
-          verticesArray[vertexID_to_verticesArrayIndex[line.vertices.get(0)]][1]
-        );
-        ptYArray.push(
-          verticesArray[vertexID_to_verticesArrayIndex[line.vertices.get(1)]][1]
-        );
-      });
-      ptXMin = Math.min.apply(null, ptXArray);
-      ptXMax = Math.max.apply(null, ptXArray);
-      ptYMin = Math.min.apply(null, ptYArray);
-      ptYMAX = Math.max.apply(null, ptYArray);
-      let pointArray = [];
-      pointArray.push({ x: ptXMin, y: ptYMin });
-      pointArray.push({ x: ptXMax, y: ptYMin });
-      pointArray.push({ x: ptXMax, y: ptYMAX });
-      pointArray.push({ x: ptXMin, y: ptYMAX });
-      let resultAdd = Area.add(
-        state,
-        layerID,
-        'area',
-        pointArray,
-        state.catalog
-      );
-      state = resultAdd.updatedState;
-      if (!isEmpty(drawingInfor)) {
-        let allVertices = state.getIn(['scene', 'layers', layerID, 'vertices']);
-        let resultInterior = this.interiorsurfacedetect(
-          state,
-          drawingInfor.drawingLine.toJS(),
-          allVertices.toJS(),
-          allLinesArray,
-          layerID
-        );
-        if (!isEmpty(resultInterior)) {
-          state = resultInterior.updatedState;
-        }
-      }
-    }
-
-    return { updatedState: state };
-  }
-
-  static removeZeroLengthLines(state, layerID) {
-    let updatedState = state
-      .getIn(['scene', 'layers', layerID, 'lines'])
-      .reduce((newState, line) => {
-        let v_id0 = line.getIn(['vertices', 0]);
-        let v_id1 = line.getIn(['vertices', 1]);
-
-        let v0 = newState.getIn([
-          'scene',
-          'layers',
-          layerID,
-          'vertices',
-          v_id0
-        ]);
-        let v1 = newState.getIn([
-          'scene',
-          'layers',
-          layerID,
-          'vertices',
-          v_id1
-        ]);
-
-        if (GeometryUtils.verticesDistance(v0, v1) === 0) {
-          newState = Line.remove(newState, layerID, line.id).updatedState;
-        }
-
-        return newState;
-      }, state);
-
-    return { updatedState };
-  }
-
-  static mergeEqualsVertices(state, layerID, vertexID) {
-    //1. find vertices to remove
-    let vertex = state.getIn([
-      'scene',
-      'layers',
-      layerID,
-      'vertices',
-      vertexID
-    ]);
-
-    if (vertex === undefined || vertex === null) return { updatedState: state };
-
-    let doubleVertices = state
-      .getIn(['scene', 'layers', layerID, 'vertices'])
-      .filter(v => {
-        return (
-          v.id !== vertexID && GeometryUtils.samePoints(vertex, v) // &&
-          //!v.lines.contains( vertexID ) &&
-          //!v.areas.contains( vertexID )
-        );
-      });
-
-    if (doubleVertices.isEmpty()) return { updatedState: state };
-
-    doubleVertices.forEach(doubleVertex => {
-      let reduced = doubleVertex.lines.reduce((reducedState, lineID) => {
-        reducedState = reducedState.updateIn(
-          ['scene', 'layers', layerID, 'lines', lineID, 'vertices'],
-          vertices => {
-            if (vertices) {
-              return vertices.map(v => (v === doubleVertex.id ? vertexID : v));
-            }
-          }
-        );
-        reducedState = Vertex.addElement(
-          reducedState,
-          layerID,
-          vertexID,
-          'lines',
-          lineID
-        ).updatedState;
-
-        return reducedState;
-      }, state);
-
-      let biReduced = doubleVertex.areas.reduce((reducedState, areaID) => {
-        reducedState = reducedState.updateIn(
-          ['scene', 'layers', layerID, 'areas', areaID, 'vertices'],
-          vertices => {
-            if (vertices)
-              return vertices.map(v => (v === doubleVertex.id ? vertexID : v));
-          }
-        );
-        reducedState = Vertex.addElement(
-          reducedState,
-          layerID,
-          vertexID,
-          'areas',
-          areaID
-        ).updatedState;
-
-        return reducedState;
-      }, reduced);
-
-      state = Vertex.remove(
-        biReduced,
-        layerID,
-        doubleVertex.id,
-        null,
-        null,
-        true
-      ).updatedState;
-    });
-
-    return { updatedState: state };
-  }
-
-  static setPropertiesOnSelected(state, layerID, properties) {
-    let selected = state.getIn(['scene', 'layers', layerID, 'selected']);
-
-    selected.lines.forEach(
-      lineID =>
-        (state = Line.setProperties(
-          state,
-          layerID,
-          lineID,
-          properties
-        ).updatedState)
-    );
-    selected.holes.forEach(
-      holeID =>
-        (state = Hole.setProperties(
-          state,
-          layerID,
-          holeID,
-          properties
-        ).updatedState)
-    );
-    selected.areas.forEach(
-      areaID =>
-        (state = Area.setProperties(
-          state,
-          layerID,
-          areaID,
-          properties
-        ).updatedState)
-    );
-    selected.items.forEach(
-      itemID =>
-        (state = Item.setProperties(
-          state,
-          layerID,
-          itemID,
-          properties
-        ).updatedState)
-    );
-
-    return { updatedState: state };
-  }
-
-  static updatePropertiesOnSelected(state, layerID, properties) {
-    let selected = state.getIn(['scene', 'layers', layerID, 'selected']);
-
-    selected.lines.forEach(
-      lineID =>
-        (state = Line.updateProperties(
-          state,
-          layerID,
-          lineID,
-          properties
-        ).updatedState)
-    );
-    selected.holes.forEach(
-      holeID =>
-        (state = Hole.updateProperties(
-          state,
-          layerID,
-          holeID,
-          properties
-        ).updatedState)
-    );
-    selected.areas.forEach(
-      areaID =>
-        (state = Area.updateProperties(
-          state,
-          layerID,
-          areaID,
-          properties
-        ).updatedState)
-    );
-    selected.items.forEach(
-      itemID =>
-        (state = Item.updateProperties(
-          state,
-          layerID,
-          itemID,
-          properties
-        ).updatedState)
-    );
-
-    return { updatedState: state };
-  }
-
-  static setAttributesOnSelected(state, layerID, attributes) {
-    let selected = state.getIn(['scene', 'layers', layerID, 'selected']);
-
-    selected.lines.forEach(
-      lineID =>
-        (state = Line.setAttributes(
-          state,
-          layerID,
-          lineID,
-          attributes
-        ).updatedState)
-    );
-    selected.holes.forEach(
-      holeID =>
-        (state = Hole.setAttributes(
-          state,
-          layerID,
-          holeID,
-          attributes
-        ).updatedState)
-    );
-    selected.items.forEach(
-      itemID =>
-        (state = Item.setAttributes(
-          state,
-          layerID,
-          itemID,
-          attributes
-        ).updatedState)
-    );
-    //selected.areas.forEach(areaID => state = Area.setAttributes( state, layerID, areaID, attributes ).updatedState);
-
-    return { updatedState: state };
-  }
-}
-
-export { Layer as default };