notebooks/Classic-OCC-Bottle.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "1c4ea27f-3c42-49c5-a168-f0389a78ab99",
   "metadata": {},
   "source": [
    "# PythonOCC example\n",
    "\n",
    "To run this example, install [pythonocc-core](https://github.com/tpaviot/pythonocc-core):\n",
    "\n",
    "```shell\n",
    "conda install -c conda-forge pythonocc-core=7.6.2 occt=7.6.2\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bd8d1987-da6b-4789-b41e-abb6dda28efa",
   "metadata": {},
   "source": [
    "## OCC Bottle\n",
    "\n",
    "Source: [core_classic_occ_bottle.py](https://github.com/tpaviot/pythonocc-demos/blob/master/examples/core_classic_occ_bottle.py)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d1249cd2-0861-4091-aee3-cebd21626e33",
   "metadata": {},
   "outputs": [],
   "source": [
    "##Copyright 2009-2015 Thomas Paviot (tpaviot@gmail.com)\n",
    "##\n",
    "##This file is part of pythonOCC.\n",
    "##\n",
    "##pythonOCC is free software: you can redistribute it and/or modify\n",
    "##it under the terms of the GNU Lesser General Public License as published by\n",
    "##the Free Software Foundation, either version 3 of the License, or\n",
    "##(at your option) any later version.\n",
    "##\n",
    "##pythonOCC is distributed in the hope that it will be useful,\n",
    "##but WITHOUT ANY WARRANTY; without even the implied warranty of\n",
    "##MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n",
    "##GNU Lesser General Public License for more details.\n",
    "##\n",
    "##You should have received a copy of the GNU Lesser General Public License\n",
    "##along with pythonOCC.  If not, see <http://www.gnu.org/licenses/>.\n",
    "\n",
    "import math\n",
    "\n",
    "from OCC.Core.gp import (\n",
    "    gp_Pnt,\n",
    "    gp_OX,\n",
    "    gp_Vec,\n",
    "    gp_Trsf,\n",
    "    gp_DZ,\n",
    "    gp_Ax2,\n",
    "    gp_Ax3,\n",
    "    gp_Pnt2d,\n",
    "    gp_Dir2d,\n",
    "    gp_Ax2d,\n",
    "    gp_Pln,\n",
    ")\n",
    "from OCC.Core.GC import GC_MakeArcOfCircle, GC_MakeSegment\n",
    "from OCC.Core.GCE2d import GCE2d_MakeSegment\n",
    "from OCC.Core.Geom import Geom_CylindricalSurface\n",
    "from OCC.Core.Geom2d import Geom2d_Ellipse, Geom2d_TrimmedCurve\n",
    "from OCC.Core.BRepBuilderAPI import (\n",
    "    BRepBuilderAPI_MakeEdge,\n",
    "    BRepBuilderAPI_MakeWire,\n",
    "    BRepBuilderAPI_MakeFace,\n",
    "    BRepBuilderAPI_Transform,\n",
    ")\n",
    "from OCC.Core.BRepPrimAPI import BRepPrimAPI_MakePrism, BRepPrimAPI_MakeCylinder\n",
    "from OCC.Core.BRepFilletAPI import BRepFilletAPI_MakeFillet\n",
    "from OCC.Core.BRepAlgoAPI import BRepAlgoAPI_Fuse\n",
    "from OCC.Core.BRepOffsetAPI import (\n",
    "    BRepOffsetAPI_MakeThickSolid,\n",
    "    BRepOffsetAPI_ThruSections,\n",
    ")\n",
    "from OCC.Core.BRepLib import breplib\n",
    "from OCC.Core.BRep import BRep_Builder\n",
    "from OCC.Core.GeomAbs import GeomAbs_Plane\n",
    "from OCC.Core.BRepAdaptor import BRepAdaptor_Surface\n",
    "from OCC.Core.TopoDS import topods, TopoDS_Compound, TopoDS_Face\n",
    "from OCC.Core.TopExp import TopExp_Explorer\n",
    "from OCC.Core.TopAbs import TopAbs_EDGE, TopAbs_FACE\n",
    "from OCC.Core.TopTools import TopTools_ListOfShape\n",
    "\n",
    "\n",
    "def face_is_plane(face: TopoDS_Face) -> bool:\n",
    "    \"\"\"\n",
    "    Returns True if the TopoDS_Face is a plane, False otherwise\n",
    "    \"\"\"\n",
    "    surf = BRepAdaptor_Surface(face, True)\n",
    "    surf_type = surf.GetType()\n",
    "    return surf_type == GeomAbs_Plane\n",
    "\n",
    "\n",
    "def geom_plane_from_face(aFace: TopoDS_Face) -> gp_Pln:\n",
    "    \"\"\"\n",
    "    Returns the geometric plane entity from a planar surface\n",
    "    \"\"\"\n",
    "    return BRepAdaptor_Surface(aFace, True).Plane()\n",
    "\n",
    "\n",
    "height = 70\n",
    "width = 50\n",
    "thickness = 30\n",
    "\n",
    "print(\"creating bottle\")\n",
    "# The points we'll use to create the profile of the bottle's body\n",
    "aPnt1 = gp_Pnt(-width / 2.0, 0, 0)\n",
    "aPnt2 = gp_Pnt(-width / 2.0, -thickness / 4.0, 0)\n",
    "aPnt3 = gp_Pnt(0, -thickness / 2.0, 0)\n",
    "aPnt4 = gp_Pnt(width / 2.0, -thickness / 4.0, 0)\n",
    "aPnt5 = gp_Pnt(width / 2.0, 0, 0)\n",
    "\n",
    "aArcOfCircle = GC_MakeArcOfCircle(aPnt2, aPnt3, aPnt4)\n",
    "aSegment1 = GC_MakeSegment(aPnt1, aPnt2)\n",
    "aSegment2 = GC_MakeSegment(aPnt4, aPnt5)\n",
    "\n",
    "# Could also construct the line edges directly using the points instead of the resulting line\n",
    "aEdge1 = BRepBuilderAPI_MakeEdge(aSegment1.Value())\n",
    "aEdge2 = BRepBuilderAPI_MakeEdge(aArcOfCircle.Value())\n",
    "aEdge3 = BRepBuilderAPI_MakeEdge(aSegment2.Value())\n",
    "\n",
    "# Create a wire out of the edges\n",
    "aWire = BRepBuilderAPI_MakeWire(aEdge1.Edge(), aEdge2.Edge(), aEdge3.Edge())\n",
    "\n",
    "# Quick way to specify the X axis\n",
    "xAxis = gp_OX()\n",
    "\n",
    "# Set up the mirror\n",
    "aTrsf = gp_Trsf()\n",
    "aTrsf.SetMirror(xAxis)\n",
    "\n",
    "# Apply the mirror transformation\n",
    "aBRespTrsf = BRepBuilderAPI_Transform(aWire.Wire(), aTrsf)\n",
    "\n",
    "# Get the mirrored shape back out of the transformation and convert back to a wire\n",
    "aMirroredShape = aBRespTrsf.Shape()\n",
    "\n",
    "# A wire instead of a generic shape now\n",
    "aMirroredWire = topods.Wire(aMirroredShape)\n",
    "\n",
    "# Combine the two constituent wires\n",
    "mkWire = BRepBuilderAPI_MakeWire()\n",
    "mkWire.Add(aWire.Wire())\n",
    "mkWire.Add(aMirroredWire)\n",
    "myWireProfile = mkWire.Wire()\n",
    "\n",
    "# The face that we'll sweep to make the prism\n",
    "myFaceProfile = BRepBuilderAPI_MakeFace(myWireProfile)\n",
    "\n",
    "# We want to sweep the face along the Z axis to the height\n",
    "aPrismVec = gp_Vec(0, 0, height)\n",
    "myBody_step1 = BRepPrimAPI_MakePrism(myFaceProfile.Face(), aPrismVec)\n",
    "\n",
    "# Add fillets to all edges through the explorer\n",
    "mkFillet = BRepFilletAPI_MakeFillet(myBody_step1.Shape())\n",
    "anEdgeExplorer = TopExp_Explorer(myBody_step1.Shape(), TopAbs_EDGE)\n",
    "\n",
    "while anEdgeExplorer.More():\n",
    "    anEdge = topods.Edge(anEdgeExplorer.Current())\n",
    "    mkFillet.Add(thickness / 12.0, anEdge)\n",
    "\n",
    "    anEdgeExplorer.Next()\n",
    "\n",
    "# Create the neck of the bottle\n",
    "neckLocation = gp_Pnt(0, 0, height)\n",
    "neckAxis = gp_DZ()\n",
    "neckAx2 = gp_Ax2(neckLocation, neckAxis)\n",
    "\n",
    "myNeckRadius = thickness / 4.0\n",
    "myNeckHeight = height / 10.0\n",
    "\n",
    "mkCylinder = BRepPrimAPI_MakeCylinder(neckAx2, myNeckRadius, myNeckHeight)\n",
    "\n",
    "myBody_step2 = BRepAlgoAPI_Fuse(mkFillet.Shape(), mkCylinder.Shape())\n",
    "\n",
    "# Our goal is to find the highest Z face and remove it\n",
    "zMax = -1.0\n",
    "\n",
    "# We have to work our way through all the faces to find the highest Z face so we can remove it for the shell\n",
    "aFaceExplorer = TopExp_Explorer(myBody_step2.Shape(), TopAbs_FACE)\n",
    "while aFaceExplorer.More():\n",
    "    aFace = topods.Face(aFaceExplorer.Current())\n",
    "    if face_is_plane(aFace):\n",
    "        aPlane = geom_plane_from_face(aFace)\n",
    "\n",
    "        # We want the highest Z face, so compare this to the previous faces\n",
    "        aPntLoc = aPlane.Location()\n",
    "        aZ = aPntLoc.Z()\n",
    "        if aZ > zMax:\n",
    "            zMax = aZ\n",
    "    aFaceExplorer.Next()\n",
    "\n",
    "facesToRemove = TopTools_ListOfShape()\n",
    "facesToRemove.Append(aFace)\n",
    "\n",
    "mk_thick_solid = BRepOffsetAPI_MakeThickSolid()\n",
    "mk_thick_solid.MakeThickSolidByJoin(\n",
    "    myBody_step2.Shape(), facesToRemove, -thickness / 50.0, 0.001\n",
    ")\n",
    "mk_thick_solid.Build()\n",
    "myBody_step3 = mk_thick_solid.Shape()\n",
    "\n",
    "# Set up our surfaces for the threading on the neck\n",
    "neckAx2_Ax3 = gp_Ax3(neckLocation, gp_DZ())\n",
    "aCyl1 = Geom_CylindricalSurface(neckAx2_Ax3, myNeckRadius * 0.99)\n",
    "aCyl2 = Geom_CylindricalSurface(neckAx2_Ax3, myNeckRadius * 1.05)\n",
    "\n",
    "# Set up the curves for the threads on the bottle's neck\n",
    "aPnt = gp_Pnt2d(2.0 * math.pi, myNeckHeight / 2.0)\n",
    "aDir = gp_Dir2d(2.0 * math.pi, myNeckHeight / 4.0)\n",
    "anAx2d = gp_Ax2d(aPnt, aDir)\n",
    "\n",
    "aMajor = 2.0 * math.pi\n",
    "aMinor = myNeckHeight / 10.0\n",
    "\n",
    "anEllipse1 = Geom2d_Ellipse(anAx2d, aMajor, aMinor)\n",
    "anEllipse2 = Geom2d_Ellipse(anAx2d, aMajor, aMinor / 4.0)\n",
    "\n",
    "anArc1 = Geom2d_TrimmedCurve(anEllipse1, 0, math.pi)\n",
    "anArc2 = Geom2d_TrimmedCurve(anEllipse2, 0, math.pi)\n",
    "\n",
    "anEllipsePnt1 = anEllipse1.Value(0)\n",
    "anEllipsePnt2 = anEllipse1.Value(math.pi)\n",
    "\n",
    "aSegment = GCE2d_MakeSegment(anEllipsePnt1, anEllipsePnt2)\n",
    "\n",
    "# Build edges and wires for threading\n",
    "anEdge1OnSurf1 = BRepBuilderAPI_MakeEdge(anArc1, aCyl1)\n",
    "anEdge2OnSurf1 = BRepBuilderAPI_MakeEdge(aSegment.Value(), aCyl1)\n",
    "anEdge1OnSurf2 = BRepBuilderAPI_MakeEdge(anArc2, aCyl2)\n",
    "anEdge2OnSurf2 = BRepBuilderAPI_MakeEdge(aSegment.Value(), aCyl2)\n",
    "\n",
    "threadingWire1 = BRepBuilderAPI_MakeWire(anEdge1OnSurf1.Edge(), anEdge2OnSurf1.Edge())\n",
    "threadingWire2 = BRepBuilderAPI_MakeWire(anEdge1OnSurf2.Edge(), anEdge2OnSurf2.Edge())\n",
    "\n",
    "# Compute the 3D representations of the edges/wires\n",
    "breplib.BuildCurves3d(threadingWire1.Shape())\n",
    "breplib.BuildCurves3d(threadingWire2.Shape())\n",
    "\n",
    "# Create the surfaces of the threading\n",
    "aTool = BRepOffsetAPI_ThruSections(True)\n",
    "aTool.AddWire(threadingWire1.Wire())\n",
    "aTool.AddWire(threadingWire2.Wire())\n",
    "aTool.CheckCompatibility(False)\n",
    "myThreading = aTool.Shape()\n",
    "\n",
    "# Build the resulting compound\n",
    "bottle = TopoDS_Compound()\n",
    "aBuilder = BRep_Builder()\n",
    "aBuilder.MakeCompound(bottle)\n",
    "aBuilder.Add(bottle, myBody_step3)\n",
    "aBuilder.Add(bottle, myThreading)\n",
    "print(\"bottle finished\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "98173799-9dea-44e0-85be-54dcc64d8192",
   "metadata": {},
   "outputs": [],
   "source": [
    "from OCC.Core.Bnd import Bnd_Box\n",
    "from OCC.Core.BRepBndLib import brepbndlib_Add\n",
    "from OCC.Core.BRepMesh import BRepMesh_IncrementalMesh\n",
    "\n",
    "def get_boundingbox(shape, tol=1e-6, use_mesh=True):\n",
    "    bbox = Bnd_Box()\n",
    "    bbox.SetGap(tol)\n",
    "    if use_mesh:\n",
    "        mesh = BRepMesh_IncrementalMesh()\n",
    "        mesh.SetParallelDefault(True)\n",
    "        mesh.SetShape(shape)\n",
    "        mesh.Perform()\n",
    "        if not mesh.IsDone():\n",
    "            raise AssertionError(\"Mesh not done.\")\n",
    "    brepbndlib_Add(shape, bbox, use_mesh)\n",
    "\n",
    "    xmin, ymin, zmin, xmax, ymax, zmax = bbox.Get()\n",
    "    return {\"xmin\": xmin, \"ymin\": ymin, \"zmin\":zmin, \"xmax\": xmax, \"ymax\": ymax, \"zmax\":zmax}\n",
    "    \n",
    "bb = get_boundingbox(bottle)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6d6835f9-4e7a-4096-9cbb-b69742349ada",
   "metadata": {},
   "source": [
    "## Tessellation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "50c942a3-7b46-4b8d-9b78-e74ccc1d2866",
   "metadata": {},
   "outputs": [],
   "source": [
    "from OCC.Core.Tesselator import ShapeTesselator\n",
    "import numpy as np\n",
    "\n",
    "def render(shape, name, group=\"Group\", color=\"#e8b024\", mesh_quality=1.0):\n",
    "    print(\"tessellating...\" )\n",
    "    tess = ShapeTesselator(shape)\n",
    "    tess.Compute(compute_edges=True, mesh_quality=mesh_quality, parallel=True)\n",
    "\n",
    "    vertices = np.array(tess.GetVerticesPositionAsTuple(), dtype='float32').reshape(-1, 3)\n",
    "    normals = np.array(tess.GetNormalsAsTuple(), dtype='float32').reshape(-1, 3)\n",
    "    triangles = np.arange(vertices.shape[0], dtype='int32').reshape(-1, 3)\n",
    "\n",
    "    edges = []\n",
    "    for i_edge in range(tess.ObjGetEdgeCount()):\n",
    "        start = tess.GetEdgeVertex(i_edge, 0)\n",
    "        for i_vertex in range(1, tess.ObjEdgeGetVertexCount(i_edge)):\n",
    "            end = tess.GetEdgeVertex(i_edge, i_vertex)\n",
    "            edges.append((start, end))\n",
    "            start = end\n",
    "\n",
    "    shapes = {\n",
    "      \"name\": \"Group\",\n",
    "      \"id\": \"/Group\",\n",
    "      \"parts\": [\n",
    "        {\n",
    "          \"name\": name,\n",
    "          \"id\": f\"/{group}/{name}\",\n",
    "          \"type\": \"shapes\",\n",
    "          \"shape\": {\n",
    "            \"vertices\": vertices,\n",
    "            \"triangles\": triangles,\n",
    "            \"normals\": normals,\n",
    "            \"edges\": edges\n",
    "          },\n",
    "          \"color\": \"#e8b024\",\n",
    "        }\n",
    "      ],\n",
    "      \"loc\": None,\n",
    "          \"bb\": bb\n",
    "    }\n",
    "\n",
    "    states = {f\"/{group}/{name}\":[1,1]}\n",
    "    print(\"... done\")\n",
    "    return shapes, states"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f448e661-c19a-4bdc-bb94-49878ce38e0c",
   "metadata": {},
   "source": [
    "# Use commodity function `show`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "31604756-f8dd-4a17-bca5-c9f41104677c",
   "metadata": {},
   "outputs": [],
   "source": [
    "from cad_viewer_widget import show, close_sidecars, CadViewer"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "59fe7488-322c-45eb-b869-b34dd073718f",
   "metadata": {},
   "source": [
    "## In the cell"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3746c358-a510-46cf-9965-6b2967f3be7e",
   "metadata": {},
   "outputs": [],
   "source": [
    "cv = show(\n",
    "    *render(bottle, \"Bottle\", mesh_quality=0.25),\n",
    "    height=800,\n",
    "    ortho=True,\n",
    "    control=\"trackball\",\n",
    "    grid=(True, True, True),\n",
    "    transparent=True,\n",
    "    pinning=True\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2f6d57a2-36a0-4301-91a3-9b982df5b73f",
   "metadata": {},
   "source": [
    "## In a sidecar"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "64a8d101-cc60-409b-b1fb-d3d7a222bc2e",
   "metadata": {},
   "outputs": [],
   "source": [
    "cv = show(\n",
    "    *render(bottle, \"Bottle\", mesh_quality=0.25),\n",
    "    height=800,\n",
    "    title=\"OCC1\", \n",
    "    anchor=\"split-right\",\n",
    "    axes=True,\n",
    "    ortho=True,\n",
    "    control=\"orbit\",\n",
    "    grid=(False, False, False),\n",
    "    transparent=True,\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "31c522b1-e7aa-4e95-b20e-6bfb420bb998",
   "metadata": {},
   "outputs": [],
   "source": [
    "cv = show(\n",
    "    *render(bottle, \"Bottle\", mesh_quality=0.25),\n",
    "    height=800,\n",
    "    title=\"OCC2\", \n",
    "    anchor=\"right\",\n",
    "    control=\"trackball\",\n",
    "    ortho=True\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cd512f17-8217-4f52-8bcd-259b316171cb",
   "metadata": {},
   "source": [
    "# Use `CadViewer` class"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3e85936d-0005-4052-b320-c5d3667149da",
   "metadata": {},
   "outputs": [],
   "source": [
    "import uuid\n",
    "from IPython.display import display, HTML\n",
    "pinning = True\n",
    "\n",
    "cv = CadViewer(\n",
    "    height=800,\n",
    "    pinning=pinning\n",
    ")\n",
    "\n",
    "display(cv.widget)\n",
    "\n",
    "if pinning:\n",
    "    image_id = \"img_\" + str(uuid.uuid4())\n",
    "    html = \"<div></div>\"\n",
    "    display(HTML(html), display_id=image_id)\n",
    "    cv.widget.image_id = image_id\n",
    "    \n",
    "cv.add_shapes(\n",
    "    *render(bottle, \"Bottle\", mesh_quality=0.25), \n",
    "    axes=True,\n",
    "    ortho=True,\n",
    "    control=\"trackball\",\n",
    "    grid=(False, False, False),\n",
    "    transparent=True\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8045a2f4-c7c5-46e1-890a-9fefd7513d6f",
   "metadata": {},
   "source": [
    "# Class, function docs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "692d6815-b665-4cb3-bb62-4e991caff763",
   "metadata": {},
   "outputs": [],
   "source": [
    "CadViewer?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cc913b2a-7676-4c71-a9af-d2795e6ed714",
   "metadata": {},
   "outputs": [],
   "source": [
    "CadViewer.add_shapes?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f3cf5a8f-af82-4b50-8882-7eeeb53ad20e",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "language_info": {
   "name": "python",
   "pygments_lexer": "ipython3"
  },
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}