TypeScript Polyhedron.get方法代碼示例

function doExpansion(
  polyhedron: Polyhedron,
  referenceName: string,
  twist?: Twist,
) {
  const reference = Polyhedron.get(referenceName);
  const n = polyhedron.getFace().numSides;
  const duplicated = duplicateVertices(polyhedron, twist);

  // TODO precalculate this
  const referenceFace =
    _.find<Face>(reference.faces, face => isExpandedFace(reference, face, n)) ||
    reference.getFace();
  const referenceLength =
    (referenceFace.distanceToCenter() / reference.edgeLength()) *
    polyhedron.edgeLength();

  const expandFaces = _.filter<Face>(duplicated.faces, face =>
    isExpandedFace(duplicated, face, n),
  );
  const refFaces = getExpandedFaces(reference, n);
  const angle = twist
    ? getTwistSign(twist) * Math.abs(getSnubAngle(reference, refFaces))
    : 0;

  // Update the vertices with the expanded-out version
  const endVertices = getResizedVertices(expandFaces, referenceLength, angle);

  return {
    animationData: {
      start: duplicated,
      endVertices,
    },
  };
}

function getTruncateTransform(polyhedron: Polyhedron, result = ''): Transform {
  if (polyhedron.isRegular()) {
    return vector => vector;
  }

  // If we're doing a bevel, we need to do some fidgeting to make sure the created
  // faces are all regular
  const truncateLength = getTruncateLength(polyhedron);
  const oldSideLength = polyhedron.edgeLength();

  const multiplier = getRectifiedMultiplier(result);
  const newSideLength = oldSideLength * multiplier;
  const faceResizeScale = newSideLength / truncateLength;

  const reference = Polyhedron.get(result);
  const normalizedResizeAmount =
    reference.faceWithNumSides(6).distanceToCenter() / reference.edgeLength() -
    polyhedron.smallestFace().distanceToCenter() / newSideLength;

  return (vector, vertex) => {
    const smallFace = find(vertex.adjacentFaces(), {
      numSides: 6,
    });
    const normal = smallFace.withPolyhedron(polyhedron).normal();
    const transform = withOrigin(smallFace.centroid(), v =>
      v
        .scale(faceResizeScale)
        .add(normal.scale(normalizedResizeAmount * newSideLength)),
    );
    return transform(vector);
  };
}

  tests.forEach(test => {
    const { start, description, operations } = test;
    let polyhedron = Polyhedron.get(start);
    let solidName = start;
    it(description, () => {
      operations.forEach(opInfo => {
        const { op, args, expected } = getOpInfo(opInfo, polyhedron);
        const result = op.apply(polyhedron, args);
        expect(result).toBeValidPolyhedron();

        polyhedron = result.result;
        expect(polyhedron.name).toBe(expected);
        solidName = result.name;
      });
    });
  });

export function setupOperations() {
  expect.extend({
    toBeValidPolyhedron(received) {
      const { result } = received;
      const isProper = isProperPolyhedron(result);
      const matchesName = result.isSame(Polyhedron.get(result.name));
      return {
        message: () => {
          if (!isProper)
            return `expected ${
              this.isNot ? 'an improper' : 'a proper'
            } CRF polyhedron`;
          return `expected polyhedron to ${this.isNot ? 'not be' : 'be'} a ${
            result.name
          }`;
        },
        pass: isProper && matchesName,
      };
    },
  });
}

// TODO deduplicate with expand/contract
function doTwist(
  polyhedron: Polyhedron,
  referenceName: string,
  twist: Twist = 'left',
) {
  const reference = Polyhedron.get(referenceName);
  const isSnub = expansionType(polyhedron) === 'snub';
  const f0 = polyhedron.largestFace();
  const n = f0.numSides;
  const twistFaces = getExpandedFaces(polyhedron, n);

  const referenceFace =
    _.find(reference.faces, face => isExpandedFace(reference, face, n)) ||
    reference.getFace();
  const referenceLength =
    (referenceFace.distanceToCenter() / reference.edgeLength()) *
    polyhedron.edgeLength();

  const refFaces = getExpandedFaces(reference, n);
  const angle = !isSnub
    ? getTwistSign(twist) * Math.abs(getSnubAngle(reference, refFaces))
    : -getSnubAngle(polyhedron, twistFaces);
  const snubTwist = angle > 0 ? 'left' : 'right';

  const duplicated = isSnub
    ? polyhedron
    : bisectEdgeFaces(twistFaces, snubTwist);
  const endVertices = getResizedVertices(twistFaces, referenceLength, angle);

  return {
    animationData: {
      start: duplicated,
      endVertices,
    },
    result: isSnub
      ? joinEdgeFaces(twistFaces, snubTwist).withVertices(endVertices)
      : undefined,
  };
}

 const polyhedra = _.map(allSolidNames, name => Polyhedron.get(name));