365 lines
12 KiB
Python
365 lines
12 KiB
Python
import FreeCAD as App
|
||
import uuid
|
||
import os
|
||
import json
|
||
from typing import List, Dict, Any, TypeVar, Callable, Type, cast
|
||
|
||
|
||
class FreeCadRepository:
|
||
_solids = []
|
||
|
||
def getAllSolids(self):
|
||
if (self._solids.__len__() == 0):
|
||
for part in App.ActiveDocument.Objects:
|
||
if (self.is_object_solid(part)):
|
||
self._solids.append(part)
|
||
|
||
return self._solids
|
||
|
||
def is_object_solid(self, obj):
|
||
if not isinstance(obj, App.DocumentObject):
|
||
return False
|
||
if hasattr(obj, 'Group'):
|
||
return False
|
||
|
||
if not hasattr(obj, 'Shape'):
|
||
return False
|
||
if not hasattr(obj.Shape, 'Mass'):
|
||
return False
|
||
if not hasattr(obj.Shape, 'Solids'):
|
||
return False
|
||
|
||
if len(obj.Shape.Solids) == 0:
|
||
return False
|
||
|
||
return True
|
||
|
||
|
||
T = TypeVar("T")
|
||
|
||
|
||
def from_list(f: Callable[[Any], T], x: Any) -> List[T]:
|
||
assert isinstance(x, list)
|
||
return [f(y) for y in x]
|
||
|
||
|
||
def from_str(x: Any) -> str:
|
||
assert isinstance(x, str)
|
||
return x
|
||
|
||
|
||
def from_dict(f: Callable[[Any], T], x: Any) -> Dict[str, T]:
|
||
assert isinstance(x, dict)
|
||
return {k: f(v) for (k, v) in x.items()}
|
||
|
||
|
||
def to_class(c: Type[T], x: Any) -> dict:
|
||
assert isinstance(x, c)
|
||
return cast(Any, x).to_dict()
|
||
|
||
|
||
class AdjacencyMatrix:
|
||
matrixError: Dict[str,str] = {}
|
||
all_parts: List[str]
|
||
first_detail: str
|
||
matrix: Dict[str, List[str]]
|
||
|
||
def __init__(self, all_parts: List[str], first_detail: str, matrix: Dict[str, List[str]]) -> None:
|
||
self.all_parts = all_parts
|
||
self.first_detail = first_detail
|
||
self.matrix = matrix
|
||
self.validateMatrix()
|
||
|
||
def whatPlaceLeadingPartIndex(self):
|
||
i = 0
|
||
for el in self.matrix:
|
||
if el == self.first_detail:
|
||
return i
|
||
i = +1
|
||
def validateMatrix(self):
|
||
for el in self.all_parts:
|
||
if(self.matrix.get(el) == None):
|
||
self.matrixError[el] = 'Not found adjacency ' + el
|
||
@staticmethod
|
||
def from_dict(obj: Any) -> 'AdjacencyMatrix':
|
||
assert isinstance(obj, dict)
|
||
all_pars = from_list(from_str, obj.get("allPars"))
|
||
first_detail = from_str(obj.get("firstDetail"))
|
||
matrix = from_dict(lambda x: from_list(from_str, x), obj.get("matrix"))
|
||
|
||
return AdjacencyMatrix(all_pars, first_detail, matrix)
|
||
|
||
def to_dict(self) -> dict:
|
||
result: dict = {}
|
||
result["allPars"] = from_list(from_str, self.all_parts)
|
||
result["firstDetail"] = from_str(self.first_detail)
|
||
result["matrix"] = from_dict(
|
||
lambda x: from_list(from_str, x), self.matrix)
|
||
if(self.matrixError.values().__len__() == 0):
|
||
result['matrixError'] = None
|
||
else:
|
||
result['matrixError'] = self.matrixError
|
||
return result
|
||
|
||
def getDictMatrix(self) -> dict:
|
||
result = {}
|
||
|
||
for k, v in self.matrix.items():
|
||
result[k] = {}
|
||
for el in v:
|
||
result[k][el] = el
|
||
|
||
return result
|
||
|
||
|
||
def adjacency_matrix_from_dict(s: Any) -> AdjacencyMatrix:
|
||
return AdjacencyMatrix.from_dict(s)
|
||
|
||
|
||
def adjacency_matrix_to_dict(x: AdjacencyMatrix) -> Any:
|
||
return to_class(AdjacencyMatrix, x)
|
||
|
||
|
||
class FreeCadMetaModel(object):
|
||
|
||
def __init__(self, label, vertex) -> None:
|
||
self.label = label
|
||
self.vertex = vertex
|
||
|
||
|
||
collision_squares_labels = []
|
||
|
||
|
||
class MeshGeometryCoordinateModel(object):
|
||
# Получение геометрии мешей
|
||
def __init__(self, x, y, z, label,):
|
||
self.x = x
|
||
self.y = y
|
||
self.z = z
|
||
self.label = label
|
||
self.cadLabel = ''
|
||
|
||
def initializePrimitivesByCoordinate(self, detailSquares):
|
||
uuidDoc = str(uuid.uuid1())
|
||
App.ActiveDocument.addObject("Part::Box", "Box")
|
||
App.ActiveDocument.ActiveObject.Label = uuidDoc
|
||
App.ActiveDocument.recompute()
|
||
part = App.ActiveDocument.getObjectsByLabel(uuidDoc)[0]
|
||
collision_squares_labels.append(uuidDoc)
|
||
part.Width = 2
|
||
part.Height = 2
|
||
part.Length = 2
|
||
part.Placement = App.Placement(
|
||
App.Vector(self.x - 1, self.y - 1, self.z - 1),
|
||
App.Rotation(App.Vector(0.00, 0.00, 1.00), 0.00))
|
||
if (detailSquares.get(self.label) is None):
|
||
detailSquares[self.label] = []
|
||
detailSquares[self.label].append(self)
|
||
self.cadLabel = uuidDoc
|
||
App.ActiveDocument.recompute()
|
||
|
||
|
||
class FS:
|
||
def readJSON(path: str):
|
||
return json.loads((open(path)).read())
|
||
|
||
def writeFile(data, filePath, fileName):
|
||
|
||
file_to_open = filePath + fileName
|
||
|
||
f = open(file_to_open, 'w', encoding='utf8')
|
||
|
||
f.write(data)
|
||
|
||
def readFile(path: str):
|
||
return open(path).read()
|
||
|
||
def readFilesTypeFolder(pathFolder: str, fileType='.json'):
|
||
filesJson = list(
|
||
filter(lambda x: x[-fileType.__len__():] == fileType, os.listdir(pathFolder)))
|
||
return filesJson
|
||
|
||
|
||
class GetAllPartsLabelsUseCase:
|
||
# Получение всех названий деталей
|
||
def call(self):
|
||
parts = []
|
||
for part in FreeCadRepository().getAllSolids():
|
||
parts.append(part.Label)
|
||
return parts
|
||
|
||
|
||
def isUnique(array, element):
|
||
for i in array:
|
||
if i == element:
|
||
return False
|
||
|
||
return True
|
||
|
||
|
||
class GetCollisionAtPrimitiveUseCase(object):
|
||
# Получение колизий примитивов
|
||
def call(self, freeCadMetaModels, detailSquares) -> Dict[str, List[str]]:
|
||
matrix: Dict[str, List[str]] = {}
|
||
for model in freeCadMetaModels:
|
||
activePart = App.ActiveDocument.getObjectsByLabel(model.label)[0]
|
||
for key in detailSquares:
|
||
if (model.label != key):
|
||
for renderPrimitive in detailSquares[key]:
|
||
primitivePart = App.ActiveDocument.getObjectsByLabel(
|
||
renderPrimitive.cadLabel)[0]
|
||
collisionResult: int = int(
|
||
activePart.Shape.distToShape(primitivePart.Shape)[0])
|
||
if (collisionResult == 0):
|
||
if matrix.get(model.label) == None:
|
||
matrix[model.label] = [renderPrimitive.label]
|
||
else:
|
||
if isUnique(matrix[model.label], renderPrimitive.label):
|
||
matrix[model.label].append(
|
||
renderPrimitive.label
|
||
)
|
||
return matrix
|
||
|
||
|
||
class GetFirstDetailUseCase:
|
||
# Получение первой детали
|
||
def call(self):
|
||
return FreeCadRepository().getAllSolids()[0].Label
|
||
|
||
|
||
class GetPartPrimitiveCoordinatesUseCase(object):
|
||
# Получение координат примитивов
|
||
def call(self, freeCadMetaModels):
|
||
meshCoordinates: list[MeshGeometryCoordinateModel] = []
|
||
for model in freeCadMetaModels:
|
||
vertexesDetail = model.vertex
|
||
labelDetail = model.label
|
||
for coords in vertexesDetail:
|
||
detailVertex = MeshGeometryCoordinateModel(
|
||
coords.X,
|
||
coords.Y,
|
||
coords.Z,
|
||
labelDetail,
|
||
)
|
||
meshCoordinates.append(detailVertex)
|
||
|
||
return meshCoordinates
|
||
|
||
|
||
class InitPartsParseUseCase():
|
||
# Инициализация парсинга
|
||
def call(self):
|
||
product_details = []
|
||
for part in FreeCadRepository().getAllSolids():
|
||
if part is not None:
|
||
model = FreeCadMetaModel(part.Label, part.Shape.Vertexes)
|
||
if (model is not None):
|
||
product_details.append(model)
|
||
return product_details
|
||
|
||
|
||
class RenderPrimitiveUseCase(object):
|
||
# Рендеринг премитивов
|
||
def call(self, meshModels: list[MeshGeometryCoordinateModel], detailSquares) -> None:
|
||
for mesh in meshModels:
|
||
mesh.initializePrimitivesByCoordinate(detailSquares)
|
||
|
||
|
||
class ClearWorkSpaceDocumentUseCase(object):
|
||
# Очистка рабочего простарнства
|
||
def call(self, detailSquares):
|
||
for key in detailSquares:
|
||
for renderPrimitive in detailSquares[key]:
|
||
primitivePart = App.ActiveDocument.getObjectsByLabel(
|
||
renderPrimitive.cadLabel)[0]
|
||
App.ActiveDocument.removeObject(primitivePart.Name)
|
||
|
||
|
||
class RenderPrimitivesScenario(object):
|
||
|
||
def __init__(
|
||
self,
|
||
initPartsParseUseCase: InitPartsParseUseCase,
|
||
getPartPrimitiveCoordinatesUseCase: GetPartPrimitiveCoordinatesUseCase,
|
||
renderPrimitiveUseCase: RenderPrimitiveUseCase,
|
||
getCollisionAtPrimitives: GetCollisionAtPrimitiveUseCase,
|
||
clearWorkSpaceDocument: ClearWorkSpaceDocumentUseCase,
|
||
) -> None:
|
||
self.initPartsParseUseCase = initPartsParseUseCase
|
||
self.getPartPrimitiveCoordinatesUseCase = getPartPrimitiveCoordinatesUseCase
|
||
self.renderPrimitiveUseCase = renderPrimitiveUseCase
|
||
self.getCollisionAtPrimitives = getCollisionAtPrimitives
|
||
self.clearWorkSpaceDocument = clearWorkSpaceDocument
|
||
|
||
def call(self) -> None:
|
||
meshCoordinates = []
|
||
detailSquares = {}
|
||
parts = self.initPartsParseUseCase.call()
|
||
meshCoordinates = self.getPartPrimitiveCoordinatesUseCase.call(parts)
|
||
self.renderPrimitiveUseCase.call(meshCoordinates, detailSquares)
|
||
matrix = self.getCollisionAtPrimitives.call(parts, detailSquares)
|
||
self.clearWorkSpaceDocument.call(detailSquares)
|
||
return matrix
|
||
|
||
|
||
class ClearWorkSpaceDocumentUseCase(object):
|
||
# Очистака рабочего пространства
|
||
def call(self, detailSquares):
|
||
for key in detailSquares:
|
||
for renderPrimitive in detailSquares[key]:
|
||
primitivePart = App.ActiveDocument.getObjectsByLabel(
|
||
renderPrimitive.cadLabel)[0]
|
||
App.ActiveDocument.removeObject(primitivePart.Name)
|
||
|
||
|
||
class CadAdjacencyMatrix:
|
||
# Матрица основанная на соприкосновении примитива с обьектами
|
||
def primitiveMatrix(self):
|
||
# Получение матрицы
|
||
matrix = RenderPrimitivesScenario(
|
||
InitPartsParseUseCase(),
|
||
GetPartPrimitiveCoordinatesUseCase(),
|
||
RenderPrimitiveUseCase(),
|
||
GetCollisionAtPrimitiveUseCase(),
|
||
ClearWorkSpaceDocumentUseCase(),
|
||
).call()
|
||
return AdjacencyMatrix(
|
||
all_parts=GetAllPartsLabelsUseCase().call(),
|
||
first_detail=GetFirstDetailUseCase().call(),
|
||
matrix=matrix,
|
||
)
|
||
# Матрица основанная на соприкосновении обьектов
|
||
def matrixBySurfaces(self):
|
||
matrix = {}
|
||
for part in FreeCadRepository().getAllSolids():
|
||
matrix[part.Label] = []
|
||
for nextPart in FreeCadRepository().getAllSolids():
|
||
if part.Label != nextPart.Label:
|
||
# Вычисление соприконсоновения площади деталей
|
||
collisionResult: int = int(
|
||
part.Shape.distToShape(nextPart.Shape)[0])
|
||
if (collisionResult == 0):
|
||
matrix[part.Label].append(nextPart.Label)
|
||
|
||
return AdjacencyMatrix(all_parts=GetAllPartsLabelsUseCase(
|
||
).call(), first_detail=GetFirstDetailUseCase().call(),
|
||
matrix=matrix
|
||
)
|
||
|
||
|
||
def main():
|
||
env = FS.readJSON('env.json')
|
||
cadFile = env['cadFilePath']
|
||
outPath = env['outPath']
|
||
if (cadFile == None):
|
||
return TypeError('CadFile not found env.json')
|
||
App.open(u'' + cadFile)
|
||
|
||
# Получение матрицы
|
||
matrixOut = CadAdjacencyMatrix().primitiveMatrix().to_dict()
|
||
import json
|
||
# Запись результата
|
||
FS.writeFile(json.dumps(matrixOut, ensure_ascii=False, indent=4), outPath,'out.json')
|
||
|
||
|
||
main()
|