├── .gitignore
├── LICENSE
├── README.md
├── requirements.txt
├── setup.py
└── volume_calculator.py


/.gitignore:
--------------------------------------------------------------------------------
 1 | *.py[co]
 2 | 
 3 | # Packages
 4 | *.egg
 5 | *.egg-info
 6 | dist
 7 | build
 8 | eggs
 9 | parts
10 | bin
11 | var
12 | sdist
13 | develop-eggs
14 | .installed.cfg
15 | 
16 | # Installer logs
17 | pip-log.txt
18 | 
19 | # Unit test / coverage reports
20 | .coverage
21 | .tox
22 | 
23 | #Translations
24 | *.mo
25 | 
26 | #Mr Developer
27 | .mr.developer.cfg
28 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | MIT License
 2 | 
 3 | Copyright (c) 2012-2020 STL-Volume-Model-Calculator (Mar Canet Sola)
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # STL Volume Model Calculator
 2 | 
 3 | This script provides functionality to calculate the volume and surface area of 3D models stored in the STL file format, as well as estimate the weight of the model based on the selected material. It is implemented in Python and supports both binary and ASCII STL files.
 4 | 
 5 | ## Installation
 6 | 
 7 | Make sure you have [Python 3](https://www.python.org/) installed. Then clone the repository and install the required Python libraries using:
 8 | 
 9 | ```bash
10 | pip install -r requirements.txt
11 | ```
12 | ## Usage
13 | 
14 | To use the script, navigate to the directory containing `volume_calculator.py` and your STL file in a terminal, then execute one of the following commands based on your needs:
15 | 
16 | ### Volume and Mass Calculation
17 | 
18 | ```bash
19 | python volume_calculator.py <filename.stl> volume --material <material_id_or_name> [--unit cm|inch]
20 | ```
21 | ### Surface Area Calculation
22 | ```bash
23 | python volume_calculator.py <filename.stl> area
24 | ```
25 | 
26 | ### Arguments:
27 | 
28 | <filename.stl>: Replace with the path to your STL file.
29 | <material_id_or_name>: Replace with the ID or name of the material you want to use for mass estimation (see the list of materials above).
30 | Options:
31 | 
32 | --unit: (Optional) Specify the unit for volume calculation. Choices are cm (default) or inch.
33 | Examples:
34 | 
35 | Calculate the volume and mass of torus.stl using ABS material:
36 | 
37 | ```bash
38 | python volume_calculator.py torus.stl volume --material ABS
39 | ```
40 | Calculate the surface area of torus.stl:
41 | ```bash
42 | python volume_calculator.py torus.stl area
43 | ```
44 | ## Materials Supported
45 | 
46 | The script comes with an extensive list of 3D printable materials each with its specified density which is used to calculate the mass of the model. The materials included are:
47 | - ABS
48 | - PLA
49 | - 3k CFRP
50 | - Plexiglass
51 | - Alumide
52 | - Aluminum
53 | - Brass
54 | - Bronze
55 | - Copper
56 | - Gold_14K
57 | - Gold_18K
58 | - Polyamide_MJF
59 | - Polyamide_SLS
60 | - Rubber
61 | - Silver
62 | - Steel
63 | - Titanium
64 | - Resin
65 | - Carbon Steel
66 | - Red Oak
67 | 
68 | ## Reporting Issues
69 | Please report any error you may find to me (mar.canet@gmail.com).
70 | 
71 | ## Author
72 | Mar Canet Sola(http://var-mar.info) - Twitter: mcanet
73 | 
74 | If you want to make a donation you can do in our PayPal account: varvarag@gmail.com
75 | 
76 | ## Additional Resources
77 | 
78 | If someone is looking for some explanation about volume calculator i recommend read this blog post: http://n-e-r-v-o-u-s.com/blog/?p=4415
79 | 
80 | 


--------------------------------------------------------------------------------
/requirements.txt:
--------------------------------------------------------------------------------
1 | numpy>=1.19
2 | numpy-stl>=2.0
3 | nibabel>=3.0
4 | pydicom>=2.0
5 | scikit-image>=0.19
6 | tqdm>=4.0
7 | 


--------------------------------------------------------------------------------
/setup.py:
--------------------------------------------------------------------------------
 1 | from setuptools import setup, find_packages
 2 | 
 3 | setup(
 4 |     name='stl-volume-calculator',
 5 |     version='1.0.0',
 6 |     author='Mar Canet',
 7 |     author_email='mar.canet@gmail.com',
 8 |     description='Calculate volume and mass of STL models (binary and ASCII), NIfTI, and DICOM files.',
 9 |     long_description=open('README.md').read(),
10 |     long_description_content_type='text/markdown',
11 |     url='https://github.com/mcanet/STL-Volume-Model-Calculator',
12 |     packages=find_packages(),
13 |     install_requires=[
14 |         'numpy>=1.19',
15 |         'numpy-stl>=2.0',
16 |         'nibabel>=3.0',
17 |         'pydicom>=2.0',
18 |         'scikit-image>=0.19',
19 |         'tqdm>=4.0'
20 |     ],
21 |     entry_points={
22 |         'console_scripts': [
23 |             'volume_calculator=volume_calculator:main',
24 |         ],
25 |     },
26 |     classifiers=[
27 |         'Programming Language :: Python :: 3',
28 |         'License :: OSI Approved :: MIT License',
29 |         'Operating System :: OS Independent',
30 |     ],
31 |     python_requires='>=3.6',
32 | )
33 | 


--------------------------------------------------------------------------------
/volume_calculator.py:
--------------------------------------------------------------------------------
  1 | #!/usr/bin/env python3
  2 | 
  3 | '''
  4 | VOLUME CALCULATION STL MODELS
  5 | Author: Mar Canet (mar.canet@gmail.com) - September 2012-2023
  6 | Description: Calculate volume and mass of STL models (binary and ASCII), NIfTI, and DICOM files.
  7 | '''
  8 | 
  9 | import struct
 10 | import sys
 11 | import re
 12 | import argparse
 13 | from tqdm import tqdm  # Add the tqdm library
 14 | 
 15 | class materialsFor3DPrinting:
 16 |     def __init__(self):
 17 |         self.materials_dict = {
 18 |             1: {'name': 'ABS', 'mass': 1.02},
 19 |             2: {'name': 'PLA', 'mass': 1.25},
 20 |             3: {'name': '3k CFRP', 'mass': 1.79},
 21 |             4: {'name': 'Plexiglass', 'mass': 1.18},
 22 |             5: {'name': 'Alumide', 'mass': 1.36},
 23 |             6: {'name': 'Aluminum', 'mass': 2.698},
 24 |             7: {'name': 'Brass', 'mass': 8.6},
 25 |             8: {'name': 'Bronze', 'mass': 9.0},
 26 |             9: {'name': 'Copper', 'mass': 9.0},
 27 |             10: {'name': 'Gold_14K', 'mass': 13.6},
 28 |             11: {'name': 'Gold_18K', 'mass': 15.6},
 29 |             12: {'name': 'Polyamide_MJF', 'mass': 1.01},
 30 |             13: {'name': 'Polyamide_SLS', 'mass': 0.95},
 31 |             14: {'name': 'Rubber', 'mass': 1.2},
 32 |             15: {'name': 'Silver', 'mass': 10.26},
 33 |             16: {'name': 'Steel', 'mass': 7.86},
 34 |             17: {'name': 'Titanium', 'mass': 4.41},
 35 |             18: {'name': 'Resin', 'mass': 1.2},
 36 |             19: {'name': 'Carbon Steel', 'mass': 7.800},
 37 |             20: {'name': 'Red Oak', 'mass': 5.700}
 38 |         }
 39 |         
 40 |     def get_material_mass(self, material_identifier):
 41 |         if material_identifier is None:
 42 |             return 1  # Default mass (density) value if no material is specified
 43 |         elif isinstance(material_identifier, int) and material_identifier in self.materials_dict:
 44 |             return self.materials_dict[material_identifier]['mass']
 45 |         elif isinstance(material_identifier, str):
 46 |             for key, value in self.materials_dict.items():
 47 |                 if value['name'].lower() == material_identifier.lower():
 48 |                     return value['mass']
 49 |             raise ValueError(f"Invalid material name: {material_identifier}")
 50 |         else:
 51 |             raise ValueError(f"Invalid material identifier: {material_identifier}")
 52 | 
 53 |     def list_materials(self):
 54 |         for key, value in self.materials_dict.items():
 55 |             print(f"{key} = {value['name']}")
 56 | 
 57 | class STLUtils:
 58 |     def __init__(self):
 59 |         self.f = None
 60 |         self.is_binary_file = None
 61 |         self.triangles = []
 62 | 
 63 |     def is_binary(self, file):
 64 |         with open(file, 'rb') as f:
 65 |             header = f.read(80).decode(errors='replace')
 66 |             return not header.startswith('solid')
 67 | 
 68 |     def read_ascii_triangle(self, lines, index):
 69 |         p1 = list(map(float, re.findall(r"[-+]?\d*\.\d+|\d+", lines[index + 1])))
 70 |         p2 = list(map(float, re.findall(r"[-+]?\d*\.\d+|\d+", lines[index + 2])))
 71 |         p3 = list(map(float, re.findall(r"[-+]?\d*\.\d+|\d+", lines[index + 3])))
 72 |         return self.signedVolumeOfTriangle(p1, p2, p3)
 73 | 
 74 |     def signedVolumeOfTriangle(self, p1, p2, p3):
 75 |         v321 = p3[0] * p2[1] * p1[2]
 76 |         v231 = p2[0] * p3[1] * p1[2]
 77 |         v312 = p3[0] * p1[1] * p2[2]
 78 |         v132 = p1[0] * p3[1] * p2[2]
 79 |         v213 = p2[0] * p1[1] * p3[2]
 80 |         v123 = p1[0] * p2[1] * p3[2]
 81 |         return (1.0 / 6.0) * (-v321 + v231 + v312 - v132 - v213 + v123)
 82 | 
 83 |     def unpack(self, sig, l):
 84 |         s = self.f.read(l)
 85 |         return struct.unpack(sig, s)
 86 | 
 87 |     def read_triangle(self):
 88 |         n = self.unpack("<3f", 12)
 89 |         p1 = self.unpack("<3f", 12)
 90 |         p2 = self.unpack("<3f", 12)
 91 |         p3 = self.unpack("<3f", 12)
 92 |         self.unpack("<h", 2)
 93 |         return (p1, p2, p3)
 94 | 
 95 |     def read_length(self):
 96 |         length = struct.unpack("@i", self.f.read(4))
 97 |         return length[0]
 98 | 
 99 |     def read_header(self):
100 |         self.f.seek(self.f.tell() + 80)
101 | 
102 |     def cm3_To_inch3Transform(self, v):
103 |         return v * 0.0610237441
104 | 
105 |     def loadSTL(self, infilename):
106 |         self.is_binary_file = self.is_binary(infilename)
107 |         self.triangles = []
108 |         try:
109 |             if self.is_binary_file:
110 |                 self.f = open(infilename, "rb")
111 |                 self.read_header()
112 |                 l = self.read_length()
113 |                 print("total triangles:", l)
114 |                 for _ in tqdm(range(l), desc="Reading triangles"):
115 |                     self.triangles.append(self.read_triangle())
116 |             else:
117 |                 with open(infilename, 'r') as f:
118 |                     lines = f.readlines()
119 |                 i = 0
120 |                 while i < len(lines):
121 |                     if lines[i].strip().startswith('facet'):
122 |                         self.triangles.append(self.read_ascii_triangle(lines, i))
123 |                         i += 7  # Skip to next facet
124 |                     else:
125 |                         i += 1
126 |         except Exception as e:
127 |             print(f"Error: {e}")
128 |             self.triangles = []
129 | 
130 |     def calculateVolume(self, unit, material_mass):
131 |         totalVolume = 0
132 |         for p1, p2, p3 in tqdm(self.triangles, desc="Calculating volume"):
133 |             totalVolume += self.signedVolumeOfTriangle(p1, p2, p3)
134 |         totalVolume /= 1000
135 |         totalMass = totalVolume * material_mass
136 | 
137 |         if totalMass <= 0:
138 |             print('Total mass could not be calculated')
139 |         else:
140 |             print('Total mass:', totalMass, 'g')
141 | 
142 |             if unit == "cm":
143 |                 print("Total volume:", totalVolume, "cm^3")
144 |             else:
145 |                 totalVolume = self.cm3_To_inch3Transform(totalVolume)
146 |                 print("Total volume:", totalVolume, "inch^3")
147 | 
148 |     def surf_area(self):
149 |         area = 0
150 |         for p1, p2, p3 in self.triangles:
151 |             ax, ay, az = p2[0] - p1[0], p2[1] - p1[1], p2[2] - p1[2]
152 |             bx, by, bz = p3[0] - p1[0], p3[1] - p1[1], p3[2] - p1[2]
153 |             cx, cy, cz = ay * bz - az * by, az * bx - ax * bz, ax * by - ay * bx
154 |             area += 0.5 * (cx * cx + cy * cy + cz * cz)**0.5
155 |         areaCm2 = area / 100
156 |         print("Total area:", areaCm2, "cm^2")
157 |         return areaCm2
158 |         
159 | class VolumeDataProcessor:
160 |     def __init__(self, file_path, file_type):
161 |         self.file_path = file_path
162 |         self.file_type = file_type
163 |         self._import_dependencies()
164 | 
165 |     def _import_dependencies(self):
166 |         global nib, pydicom, measure, np, mesh
167 | 
168 |         try:
169 |             import nibabel as nib
170 |         except ImportError:
171 |             print("Nibabel is not installed. Install it for NIfTI file support.")
172 | 
173 |         try:
174 |             import pydicom
175 |         except ImportError:
176 |             print("Pydicom is not installed. Install it for DICOM file support.")
177 | 
178 |         try:
179 |             from skimage import measure
180 |         except ImportError:
181 |             print("Scikit-Image is not installed. Install it for image processing support.")
182 | 
183 |         try:
184 |             import numpy as np
185 |         except ImportError:
186 |             print("Numpy is not installed. Install it for numerical operations.")
187 | 
188 |         try:
189 |             import stl.mesh as mesh
190 |         except ImportError:
191 |             print("numpy-stl is not installed. Install it for STL mesh support.")
192 | 
193 |     def read_volume_data(self):
194 |         if self.file_type == "nii":
195 |             try:
196 |                 img = nib.load(self.file_path)
197 |                 return img.get_fdata()
198 |             except ImportError:
199 |                 print("Nibabel is not installed. Install it for NIfTI file support.")
200 |                 sys.exit(1)
201 |         elif self.file_type == "dcm":
202 |             try:
203 |                 ds = pydicom.dcmread(self.file_path)
204 |                 return ds.pixel_array
205 |             except ImportError:
206 |                 print("Pydicom is not installed. Install it for DICOM file support.")
207 |                 sys.exit(1)
208 |         else:
209 |             raise ValueError("Unsupported file type")
210 | 
211 |     def generate_isosurface(self, data):
212 |         verts, faces, _, _ = measure.marching_cubes(data, level=0.5)
213 |         surface_mesh = mesh.Mesh(np.zeros(faces.shape[0], dtype=mesh.Mesh.dtype))
214 |         for i, f in enumerate(faces):
215 |             for j in range(3):
216 |                 surface_mesh.vectors[i][j] = verts[f[j],:]
217 |         return surface_mesh
218 |     
219 |     # Calculate surface area of the mesh
220 |     def calculate_surface_area(self, surface_mesh):
221 |         area = 0.0
222 |         for f in surface_mesh.vectors:
223 |             p0, p1, p2 = f
224 |             a = np.linalg.norm(p1 - p0)
225 |             b = np.linalg.norm(p2 - p1)
226 |             c = np.linalg.norm(p0 - p2)
227 |             s = (a + b + c) / 2.0
228 |             area += (s * (s - a) * (s - b) * (s - c)) ** 0.5
229 |         return area
230 | 
231 |     # Calculate volume of the mesh
232 |     def calculate_volume(self, surface_mesh):
233 |         volume = 0.0
234 |         for f in surface_mesh.vectors:
235 |             p1, p2, p3 = f
236 |             v321 = p3[0] * p2[1] * p1[2]
237 |             v231 = p2[0] * p3[1] * p1[2]
238 |             v312 = p3[0] * p1[1] * p2[2]
239 |             v132 = p1[0] * p3[1] * p2[2]
240 |             v213 = p2[0] * p1[1] * p3[2]
241 |             v123 = p1[0] * p2[1] * p3[2]
242 |             volume += (-v321 + v231 + v312 - v132 - v213 + v123) / 6.0
243 |         return abs(volume)
244 |         
245 | def main():
246 |     parser = argparse.ArgumentParser(description='Calculate volume or surface area of STL models.')
247 |     parser.add_argument('filename', help='Path to the file')
248 |     parser.add_argument('calculation', choices=['volume', 'area'], help='Choose between calculating volume or surface area')
249 |     parser.add_argument('--unit', choices=['cm', 'inch'], default='cm', help='Unit for the volume calculation (default: cm)')
250 |     parser.add_argument('--material', type=int, choices=range(1, 21),default=2, help='Material ID for mass calculation')
251 |     parser.add_argument('--filetype', choices=['stl', 'nii', 'dcm'], default='stl', help='Type of the input file: stl, nii, dcm')
252 | 
253 |     args = parser.parse_args()
254 | 
255 |     if args.filetype == 'stl':
256 |         mySTLUtils = STLUtils()
257 |         mySTLUtils.loadSTL(args.filename)
258 |         if args.calculation == 'volume':
259 |             material_mass = materialsFor3DPrinting().get_material_mass(args.material)
260 |             mySTLUtils.calculateVolume(args.unit, material_mass)
261 |         elif args.calculation == 'area':
262 |             mySTLUtils.surf_area()
263 |     elif args.filetype in ['nii', 'dcm']:
264 |         volumeDataProcessor = VolumeDataProcessor(args.filename, args.filetype)
265 |         data = volumeDataProcessor.read_volume_data()
266 |         surface_mesh = volumeDataProcessor.generate_isosurface(data)
267 |         if args.calculation == 'volume':
268 |             print('Volume:', volumeDataProcessor.calculate_volume(surface_mesh), 'units^3')
269 |         elif args.calculation == 'area':
270 |             print('Surface area:', volumeDataProcessor.calculate_surface_area(surface_mesh), 'units^2')
271 | 
272 | if __name__ == '__main__':
273 |     main()
274 | 


--------------------------------------------------------------------------------