Bitbybit Docs
    Preparing search index...

    Class ManifoldOperations

    Alterar sólidos Manifold para lá das operações booleanas: envolvê-los num invólucro convexo, fatiá-los e projetá-los em secções transversais, refinar e suavizar as suas malhas, simplificá-los, compô-los e decompô-los, e calcular normais e curvatura em canais de propriedades dos vértices. Um canal de propriedades é um número por vértice guardado na malha, como os três canais de uma normal. Cada método devolve um novo sólido.

    Index

    Constructors

    constructor

    adjustments

    calculateNormals calculateCurvature refineToTolerance refineToLength refine smoothOut smoothByNormals simplify setProperties

    basic

    setTolerance reserveIds asOriginal

    composition

    compose decompose

    cross sections

    slice project

    hulls

    hull hullPoints

    Constructors

    adjustments

    • Calcula uma normal para cada vértice a partir da malha e guarda-a em três canais de propriedades a começar em normalIdx.

      Arestas mais vivas do que minSharpAngle, em graus, mantêm normais separadas de cada lado e ficam nítidas; a 0 cada triângulo mantém a sua própria normal. Faces planas de vários triângulos ficam planas.

      Parameters

      Returns Promise<ManifoldPointer>

      O sólido com as normais armazenadas

      const withNormals = await bitbybit.manifold.manifold.operations.calculateNormals({ manifold: shape, normalIdx: 0, minSharpAngle: 60 });

    • Calcula quão fortemente a superfície se curva em cada vértice e guarda-o em canais de propriedades: curvatura gaussiana em gaussianIdx, curvatura média em meanIdx.

      A curvatura é o inverso do raio de curvatura, positiva onde a superfície é convexa e negativa onde é côncava; um índice abaixo de 0 salta esse canal.

      Parameters

      Returns Promise<ManifoldPointer>

      O sólido com a curvatura armazenada

      const withCurvature = await bitbybit.manifold.manifold.operations.calculateCurvature({ manifold: shape, gaussianIdx: 0, meanIdx: 1 });

    • Adiciona triângulos a um sólido suavizado até que cada ponto da sua malha fique dentro de tolerance da superfície suave, de modo que regiões muito curvas recebem mais triângulos do que as planas.

      Só um sólido que tenha sido suavizado com smoothOut ou smoothByNormals muda; qualquer outro volta como uma cópia.

      Parameters

      Returns Promise<ManifoldPointer>

      O sólido refinado

      const finer = await bitbybit.manifold.manifold.operations.refineToTolerance({ manifold: smoothed, tolerance: 0.01 });

    • Adiciona triângulos a um sólido dividindo cada aresta em troços com aproximadamente o comprimento dado, adicionando vértices interiores para manter os triângulos uniformes.

      Num sólido suavizado com smoothOut ou smoothByNormals os novos vértices movem-se para a superfície suave; caso contrário a superfície fica como está.

      Parameters

      Returns Promise<ManifoldPointer>

      O sólido refinado

      const finer = await bitbybit.manifold.manifold.operations.refineToLength({ manifold: smoothed, length: 0.5 });

    • Adiciona triângulos a um sólido dividindo cada aresta em number troços; com 2, cada triângulo torna-se quatro.

      Num sólido suavizado com smoothOut ou smoothByNormals os novos vértices movem-se para a superfície suave; caso contrário os novos triângulos ficam planos.

      Parameters

      Returns Promise<ManifoldPointer>

      O sólido refinado

      const finer = await bitbybit.manifold.manifold.operations.refine({ manifold: smoothed, number: 2 });

    • Marca um sólido para suavização calculando tangentes a partir dos seus triângulos, de modo que um refine ou refineToLength posterior curva os novos triângulos numa superfície suave.

      Arestas mais vivas do que minSharpAngle, em graus, mantêm-se vivas; minSmoothness acima de 0 arredonda um pouco essas, e 1 suaviza tudo. A própria geometria não muda até ser refinada.

      Parameters

      Returns Promise<ManifoldPointer>

      O sólido com tangentes de suavização

      const smoothed = await bitbybit.manifold.manifold.operations.smoothOut({ manifold: cube, minSharpAngle: 60, minSmoothness: 0 });
      const rounded = await bitbybit.manifold.manifold.operations.refineToLength({ manifold: smoothed, length: 0.5 });

    • Marca um sólido para suavização usando as normais guardadas nas suas propriedades de vértice, de modo que um refine ou refineToLength posterior curva os novos triângulos numa superfície suave.

      normalIdx é o primeiro dos três canais de normais, tal como calculateNormals os guarda; onde as normais num vértice discordam a aresta mantém-se viva.

      Parameters

      Returns Promise<ManifoldPointer>

      O sólido com tangentes de suavização

      const smoothed = await bitbybit.manifold.manifold.operations.smoothByNormals({ manifold: withNormals, normalIdx: 0 });

    • Remove vértices da malha de um sólido mantendo cada superfície dentro de tolerance de onde estava, para reduzir a contagem de triângulos.

      O resultado mantém um subconjunto dos vértices originais; o próprio valor de tolerância do sólido fica inalterado.

      Parameters

      Returns Promise<ManifoldPointer>

      O sólido simplificado

      const lighter = await bitbybit.manifold.manifold.operations.simplify({ manifold: shape, tolerance: 0.05 });

    • Reescreve as propriedades de vértice de um sólido com uma função que recebe a posição e as propriedades antigas de cada vértice e preenche as novas.

      numProp define quantas propriedades cada vértice tem depois, de modo que canais podem ser adicionados ou removidos; ler para lá da contagem antiga ou escrever para lá da nova é indefinido.

      Parameters

      Returns Promise<ManifoldPointer>

      O sólido com as novas propriedades

      const colored = await bitbybit.manifold.manifold.operations.setProperties({
          manifold: shape,
          numProp: 3,
          propFunc: (newProp, position) => { newProp[0] = position[0]; newProp[1] = position[1]; newProp[2] = position[2]; },
      });

    basic

    • Dá a um sólido uma nova tolerância, o erro de arredondamento que pode transportar, e simplifica a sua malha quando a tolerância cresce.

      Triângulos mais finos do que a tolerância são tratados como degenerados e removidos.

      Parameters

      Returns Promise<ManifoldPointer>

      O sólido com a nova tolerância

      const coarser = await bitbybit.manifold.manifold.operations.setTolerance({ manifold: shape, tolerance: 0.01 });

    • Reserva uma sequência de count ids de malha únicos e devolve o primeiro, para marcar conjuntos de triângulos que possam ser encontrados de novo depois de operações posteriores.

      Atribua-os ao runOriginalID de uma malha antes de construir um sólido a partir dela, por exemplo para manter vários materiais separados.

      Parameters

      Returns Promise<number>

      O primeiro dos ids reservados; os restantes seguem em sequência

      const firstId = await bitbybit.manifold.manifold.operations.reserveIds({ count: 2 });

    • Cria uma cópia de um sólido que conta como um novo original, de modo que a cópia pode transportar as suas próprias propriedades de vértice, como um mapeamento UV diferente, e ser distinguida daquilo de que foi construída.

      As faces coplanares são fundidas e as arestas entre elas colapsadas pelo caminho; mantenha antes a via da malha quando essas arestas tiverem de ficar.

      Parameters

      Returns Promise<ManifoldPointer>

      A cópia marcada como original

      const original = await bitbybit.manifold.manifold.operations.asOriginal({ manifold: shape });

    composition

    • Agrupa vários sólidos num só, o inverso de decompose.

      Os sólidos que se sobrepõem são fundidos, como faria uma união booleana; os mantidos afastados continuam a ser peças separadas do mesmo resultado.

      Parameters

      Returns Promise<ManifoldPointer>

      Um sólido que contém todos eles

      const packed = await bitbybit.manifold.manifold.operations.compose({ manifolds: [cube, sphere] });

    • Divide um sólido nos seus pedaços separados e desligados, o inverso de compose.

      Um sólido que seja todo um só pedaço volta como uma lista com uma cópia.

      Parameters

      Returns Promise<ManifoldPointer[]>

      As partes separadas

      const pieces = await bitbybit.manifold.manifold.operations.decompose({ manifold: packed });

    cross sections

    • Corta um sólido com um plano paralelo ao plano XY à altura Z dada e devolve a secção plana como uma secção transversal.

      Uma altura no fundo da caixa delimitadora do sólido dá as suas faces inferiores; uma altura no topo dá uma secção transversal vazia.

      Parameters

      Returns Promise<CrossSectionPointer>

      A secção como uma secção transversal

      const section = await bitbybit.manifold.manifold.operations.slice({ manifold: sphere, height: 2 });

    • Achata um sólido sobre o plano XY e devolve o seu contorno como uma secção transversal, como a sua sombra sob uma luz diretamente acima.

      Parameters

      Returns Promise<CrossSectionPointer>

      O contorno como uma secção transversal

      const shadow = await bitbybit.manifold.manifold.operations.project({ manifold: shape });

    hulls

    • Envolve um sólido no seu invólucro convexo, a menor forma sem reentrâncias que o contém, como película retrátil bem apertada à sua volta.

      Parameters

      Returns Promise<ManifoldPointer>

      O invólucro convexo

      const wrapped = await bitbybit.manifold.manifold.operations.hull({ manifold: shape });

    • Envolve pontos, sólidos ou uma mistura de ambos num só invólucro convexo, a menor forma sem reentrâncias que os contém a todos.

      Parameters

      Returns Promise<ManifoldPointer>

      O invólucro convexo

      const wrapped = await bitbybit.manifold.manifold.operations.hullPoints({ points: [[0, 0, 0], [10, 0, 0], [0, 10, 0], [0, 0, 10]] });

    Settings

    Member Visibility

    On This Page

    Constructors
    adjustments
    basic
    composition
    cross sections
    hulls