jorodeo avatar jorodeo committed e3d6247

Further work on new capillary array sensor enclosure design. Added mounting holes for
guide plates, led pcb, diffuser, and diffuser standoffs.

Comments (0)

Files changed (2)

capillary_enclosure.py

     def __init__(self,params):
         self.params = params
         self.add_sensor_cutout()
-        #self.add_sensor_cable_hole()
         self.add_capillary_holes()
-        #self.add_capillary_clamp_holes()
-        #self.add_led_cable_hole()
+        self.add_guide_tap_holes()
+        self.add_led_tap_holes()
         super(Capillary_Enclosure,self).__init__(self.params)
 
     def make(self):
         super(Capillary_Enclosure,self).make()
-        #self.make_rubber_band_notch()
-        self.make_backlight_standoffs()
-        self.make_led_plate()
-        self.make_diffuser_plate()
         self.make_sensor()
-        #self.make_clamp_standoffs()
-        self.make_clamp_plates()
-        self.make_led_standoffs()
-        self.make_diffuser_standoffs()
         self.make_capillary()
         self.make_guide_plates()
+        self.make_led_pcb()
+        self.make_diffuser()
+        self.make_led_standoffs()
 
     def get_assembly(self,**kwargs):
         """
         Get enclosure assembly
         """
         try:
-            show_led_plate = kwargs['show_led_plate']
-        except KeyError:
-            show_led_plate = True
-        try:
-            show_diffuser_plate = kwargs['show_diffuser_plate']
-        except KeyError:
-            show_diffuser_plate = True
-        try:
             show_sensor = kwargs['show_sensor']
         except KeyError:
             show_sensor = True
         try:
-            show_clamp_standoffs = kwargs['show_clamp_standoffs']
+            show_capillary = kwargs['show_capillary']
         except KeyError:
-            show_clamp_standoffs = True
+            show_capillary = True
         try:
-            show_clamp_plates = kwargs['show_clamp_plates']
+            show_guide_plates = kwargs['show_guide_plates']
         except KeyError:
-            show_clamp_plates = True
+            show_guide_plates = True
         try:
-            show_led_standoffs = kwargs['show_led_standoffs']
+            show_led_pcb = kwargs['show_led_pcb']
         except KeyError:
-            show_led_standoffs = True
+            show_led_pcb = True
+        try:
+            show_diffuser = kwargs['show_diffuser']
+        except KeyError:
+            show_diffuser = True
         try:
             show_diffuser_standoffs = kwargs['show_diffuser_standoffs']
         except KeyError:
             show_diffuser_standoffs = True
         try:
-            show_capillary = kwargs['show_capillary']
-        except KeyError:
-            show_capillary = True
-        try:
-            show_guide_plate = kwargs['show_guide_plate']
-        except KeyError:
-            show_guide_plate = True
-        try:
             explode = kwargs['explode']
         except KeyError:
             explode = (0,0,0)
+
         explode_x, explode_y, explode_z = explode
 
-
         parts_list = super(Capillary_Enclosure,self).get_assembly(**kwargs)
-
-        # Add led plate
         x,y,z = self.params['inner_dimensions']
         wall_thickness = self.params['wall_thickness']
-        led_standoff_length = self.params['led_standoff_length']
-        led_plate = self.led_plate
-        z_shift = 0.5*z - led_standoff_length - 0.5*wall_thickness 
-        z_shift += explode_z
-        led_plate = Translate(led_plate,v=(0,0,z_shift))
-        if show_led_plate:
-            parts_list.append(led_plate)
-
-        # Add diffuser plate
-        diffuser_standoff_length = self.params['diffuser_standoff_length']
-        diffuser_plate = self.diffuser_plate
-        z_shift = 0.5*z - 1.5*wall_thickness -  led_standoff_length - diffuser_standoff_length
-        z_shift += explode_z
-        diffuser_plate = Translate(diffuser_plate, v=(0,0,z_shift))
-        if show_diffuser_plate:
-            parts_list.append(diffuser_plate)
 
         # Add sensor
         sensor_x, sensor_y, sensor_z = self.params['sensor_dimensions']
         if show_sensor:
             parts_list.append(sensor)
 
-
-        # Add led standoffs
-        led_standoff_length = self.params['led_standoff_length']
-        z_shift = 0.5*z - 0.5*led_standoff_length
-        z_shift += explode_z
-        for standoff in self.led_standoff_list:
-            standoff = Translate(standoff,v=(0,0,z_shift))
-            if show_led_standoffs:
-                parts_list.append(standoff)
-
-        # Add diffuser standoffs
-        diffuser_standoff_length = self.params['diffuser_standoff_length']
-        z_shift = 0.5*z - led_standoff_length - wall_thickness - 0.5*diffuser_standoff_length
-        z_shift += explode_z
-        for standoff in self.diffuser_standoff_list:
-            standoff = Translate(standoff,v=(0,0,z_shift))
-            if show_diffuser_standoffs:
-                parts_list.append(standoff)
-
         # Add capillary
         cap_offset_x, cap_offset_y = self.params['capillary_hole_offset']
         cap_hole_diam = self.params['capillary_diam']
         y_shift = cap_offset_x
         z_shift = -0.5*z + 1.5*guide_z 
         guide_plate_top = Translate(self.guide_plate_top,v=[0,y_shift,z_shift])
-
-        if show_guide_plate:
+        if show_guide_plates:
            parts_list.extend([guide_plate_pos,guide_plate_neg,guide_plate_top])
 
+        # Add led pcb
+        pcb_x, pcb_y, pcb_z = self.params['led_pcb_dimensions']
+        z_shift = 0.5*z - 0.5*pcb_z
+        led_pcb = Translate(self.led_pcb,v=(0,0,z_shift))
+        if show_led_pcb:
+            parts_list.append(led_pcb)
+
+        # Add diffuser
+        diff_x, diff_y, diff_z = self.params['diffuser_dimensions']
+        diffuser_standoff_height = self.params['diffuser_standoff_height']
+        z_shift = 0.5*z - pcb_z - 0.5*diff_z -  diffuser_standoff_height
+        diffuser = Translate(self.diffuser,v=(0,0,z_shift))
+        if show_diffuser:
+            parts_list.append(diffuser)
+
+        # Add diffuser standoffs
+        led_hole_tuples = self.get_led_holes()
+        z_shift = 0.5*z - pcb_z- 0.5*self.params['diffuser_standoff_height']
+        for x_shift,y_shift, dummy in led_hole_tuples:
+            if x_shift < 0:
+                standoff = self.diffuser_standoff_neg
+            else:
+                standoff = self.diffuser_standoff_pos
+            standoff = Translate(standoff,v=(x_shift,y_shift,z_shift))
+            if show_diffuser_standoffs:
+                parts_list.append(standoff)
+
         return parts_list
 
+
     def get_opaque_projection(self,show_ref_cube=True, spacing_factor=4):
         """
         Get 2D projected layout of parts for laser cutting.
         x,y,z = self.params['inner_dimensions']
         wall_thickness = self.params['wall_thickness']
         spacing = spacing_factor*wall_thickness
-        
-        # Add led plate - two in case of mistakes
-        led_plate_x, led_plate_y = self.params['led_plate_xy']
-        led_plate = self.led_plate
-        x_shift = 0.5*self.bottom_x + 0.5*led_plate_x + spacing
-        y_shift = 0.5*self.bottom_y + 0.5*led_plate_y + spacing
-        led_plate0 = Translate(led_plate,v=(x_shift,y_shift,0))
-        led_plate1 = Translate(led_plate,v=(-x_shift,y_shift,0))
-        led_plate0 = Projection(led_plate0)
-        led_plate1 = Projection(led_plate1)
-        parts_list.append(led_plate0)
-        parts_list.append(led_plate1)
-
-        # Add clamping plates
-        clamp_x, clamp_y, clamp_z = self.params['capillary_clamp_plate_dimensions']
-        for i in range(0,2):
-            for clamp_plate, sgn in zip(self.clamp_plate_list,(-1,1)):
-                x_shift = sgn*(0.5*self.bottom_x + 0.5*clamp_x + spacing)
-                y_shift = -0.5*self.bottom_y -0.5*clamp_y - spacing - i*(spacing + clamp_y)
-                clamp_plate = Translate(clamp_plate,v=(x_shift,y_shift,0))
-                clamp_plate = Projection(clamp_plate)
-                parts_list.append(clamp_plate)
 
         return parts_list
 
-    def get_diffuser_projection(self,ref_cube=True,spacing_factor=4):
-        """
-        Get 2D projection for diffuser - projection is separate because different 
-        materials will be used.
-        """
-        parts_list = []
-        wall_thickness = self.params['wall_thickness']
-        spacing = spacing_factor*wall_thickness
 
-        # Add diffuer plate projection
-        diffuser_plate = self.diffuser_plate
-        diffuser_plate = Projection(diffuser_plate)
-        parts_list.append(diffuser_plate)
 
-        # Add reference cube
-        diffuser_x, diffuser_y = self.params['diffuser_plate_xy']
-        cube = Cube(size=(INCH2MM, INCH2MM, INCH2MM))
-        x_shift = 0.0
-        y_shift = 0.5*diffuser_y + 0.5*INCH2MM + spacing
-        cube = Translate(cube,v=(x_shift,y_shift,0))
-        cube = Projection(cube)
-        if ref_cube:
-            parts_list.append(cube)
-
-        return parts_list 
 
     def add_capillary_holes(self):
         """
             hole_list.append(hole)
         self.params['hole_list'].extend(hole_list)
 
- 
     def add_sensor_cutout(self):
         """
         Add cutout for sensor
         """
         hole_list = [] 
-
         sensor_width = self.params['sensor_width']
         sensor_length = self.params['sensor_length']
         hole_offset = self.params['sensor_hole_offset']
-        
         x_pos = 0;
         y_pos = -hole_offset;
-            
         hole = {
                     'panel'    : 'bottom', 
                     'type'     : 'square', 
         hole_list.append(hole)
         self.params['hole_list'].extend(hole_list)
 
-
     def add_capillary_clamp_holes(self):
         """
         Add holes for clamping capillary in place
 
         self.add_holes(hole_list)
 
-
-    def make_backlight_standoffs(self):
-        hole_list = []
-        hole_diam = self.params['standoff_hole_diameter']
-        x_pos_list = [x for x,y in self.standoff_xy_pos]
-
-        
-        self.backlight_standoff_xy = []
-        for x_pos in x_pos_list:
-            y_pos = 0
-            self.backlight_standoff_xy.append((x_pos,y_pos))
-            hole = {
-                    'panel'    : 'top',
-                    'type'     : 'round',
-                    'location' : (x_pos, y_pos),
-                    'size'     : hole_diam,
-                    }
-            hole_list.append(hole)
-
-        self.add_holes(hole_list)
-
-    def make_led_plate(self):
-        wall_thickness = self.params['wall_thickness']
-        plate_x, plate_y = self.params['led_plate_xy']
-        hole_diam = self.params['standoff_hole_diameter']
-        sensor_length = self.params['sensor_length']
-        led_num = self.params['led_num']
-        led_slot_x, led_slot_y = self.params['led_slot_xy']
-
-        self.led_plate = Cube(size=(plate_x,plate_y,wall_thickness))
-
-        # Add standoff holes
-        hole_list = []
-        for x_pos, y_pos in self.backlight_standoff_xy:
-            hole = {
-                    'panel'    : 'led_plate',
-                    'type'     : 'round',
-                    'location' : (x_pos, y_pos),
-                    'size'     : hole_diam,
-                    }
-            hole_list.append(hole)
-
-        # Add led holes
-        x_pos_array = scipy.linspace(-0.5*sensor_length + 1.0, 0.5*sensor_length -1.0, led_num)
-        for x_pos in x_pos_array:
-            y_pos = 0.0
-            hole = {
-                    'panel'    : 'led_plate',
-                    'type'     : 'rounded_square',
-                    'location' : (x_pos, y_pos),
-                    'size'     : (led_slot_x, led_slot_y, 0.5*led_slot_y),
-                    }
-            hole_list.append(hole)
-        
-        self.add_holes(hole_list)
-
-    def make_diffuser_plate(self):
-        wall_thickness = self.params['wall_thickness']
-        plate_x, plate_y = self.params['diffuser_plate_xy']
-        hole_diam = self.params['standoff_hole_diameter']
-
-        self.diffuser_plate = Cube(size=(plate_x,plate_y,wall_thickness))
-
-        # Add standoff holes
-        hole_list = []
-        for x_pos, y_pos in self.backlight_standoff_xy:
-            hole = {
-                    'panel'    : 'diffuser_plate',
-                    'type'     : 'round',
-                    'location' : (x_pos, y_pos),
-                    'size'     : hole_diam,
-                    }
-            hole_list.append(hole)
-        self.add_holes(hole_list)
-
     def make_sensor(self):
         sensor_x, sensor_y, sensor_z = self.params['sensor_dimensions']
         hole_offset = self.params['sensor_hole_offset']
         sensor = plate_w_holes(sensor_x, sensor_y, sensor_z, hole_list)
         self.sensor = Translate(sensor,v=(0,-hole_offset,0))
 
-    def make_clamp_standoffs(self):
-        hole_space = self.params['sensor_mount_hole_space']
-        standoff_diam = self.params['capillary_clamp_standoff_diam']
-        standoff_length = self.params['capillary_clamp_standoff_length']
-        standoff_hole_diam = self.params['capillary_clamp_hole_diam']
-
-        r = 0.5*standoff_diam
-        standoff_template = Cylinder(h=standoff_length, r1=r, r2=r)
-        r = 0.5*standoff_hole_diam
-        cut_cyl = Cylinder(h=2*standoff_length, r1=r, r2=r)
-        standoff_template = Difference([standoff_template,cut_cyl])
-        
-        self.clamp_standoff_list = []
-        for x_pos, y_pos in self.capillary_clamp_holes_xy:
-            standoff = Translate(standoff_template, v=(x_pos, y_pos,0))
-            self.clamp_standoff_list.append(standoff)
-
-    def make_clamp_plates(self):
-        plate_x, plate_y, plate_z = self.params['capillary_clamp_plate_dimensions']
-        clamp_hole_space = self.params['capillary_clamp_hole_space']
-        hole_diam = self.params['capillary_clamp_hole_diam']
-
-        # Create hole list
-        hole_list = []
-        for i in (-1,1):
-            x_pos = 0.0
-            y_pos = i*0.5*clamp_hole_space 
-            hole = (x_pos, y_pos, hole_diam)
-            hole_list.append(hole)
-
-        # Create clamp plates
-        self.clamp_plate_list = []
-        for i in (0,2):
-            clamp_plate = plate_w_holes(plate_x, plate_y, plate_z,hole_list)
-            self.clamp_plate_list.append(clamp_plate)
-
-    def make_led_standoffs(self):
-        standoff_diam = self.params['led_standoff_diam']
-        standoff_length = self.params['led_standoff_length']
-
-        r = 0.5*standoff_diam
-        standoff_template = Cylinder(h=standoff_length,r1=r,r2=r)
-
-        self.led_standoff_list = []
-        for x_pos, y_pos in self.backlight_standoff_xy:
-            standoff = Translate(standoff_template,v=(x_pos, y_pos, 0))
-            self.led_standoff_list.append(standoff)
-
-
-    def make_diffuser_standoffs(self):
-        standoff_diam = self.params['diffuser_standoff_diam']
-        standoff_length = self.params['diffuser_standoff_length']
-        r = 0.5*standoff_diam
-        standoff_template = Cylinder(h=standoff_length,r1=r,r2=r)
-        self.diffuser_standoff_list = []
-        for x_pos, y_pos in self.backlight_standoff_xy:
-            standoff = Translate(standoff_template,v=(x_pos,y_pos,0))
-            self.diffuser_standoff_list.append(standoff)
-
     def make_capillary(self):
         diameter = self.params['capillary_diam']
         length = self.params['capillary_length']
         capillary = Rotate(capillary, a=90, v=(0,1,0))
         self.capillary = capillary
 
-
     def make_guide_plates(self):
         guide_x, guide_y, guide_z = self.params['guide_plate_dimensions']
-        self.guide_plate_pos = Cube(size=(guide_x, guide_y, guide_z))
-        self.guide_plate_neg = Cube(size=(guide_x, guide_y, guide_z))
+        hole_diam = self.params['guide_thru_hole_diam']
+        hole_offset = self.params['guide_hole_offset']
+
+        # Create pos and neg guide plates
+        hole_list_pos = []
+        hole_list_neg = []
+        for i in (-1,1):
+            x_pos = i*(0.5*guide_x - hole_offset) 
+            y_pos = 0.5*guide_y - hole_offset 
+            hole_pos = (x_pos, y_pos, hole_diam)
+            hole_neg = (x_pos, -y_pos, hole_diam)
+            hole_list_pos.append(hole_pos)
+            hole_list_neg.append(hole_neg)
+        self.guide_plate_pos = plate_w_holes(guide_x, guide_y, guide_z, holes=hole_list_pos)
+        self.guide_plate_neg = plate_w_holes(guide_x, guide_y, guide_z, holes=hole_list_neg)
+
+        # Create top guide plate
+        top_x, top_y, top_z = self.get_guide_plate_top_dim()
+        hole_list_top = self.get_guide_plate_holes(hole_type='through')
+        self.guide_plate_top = plate_w_holes(top_x,top_y,top_z,holes=hole_list_top)
+
+    def add_guide_tap_holes(self):
+        hole_tuples = self.get_guide_plate_holes(hole_type='tap')
+        hole_list = []
+        for x,y,diam in hole_tuples:
+            hole = {
+                    'panel'    : 'bottom',
+                    'type'     : 'round',
+                    'location' : (x,y),
+                    'size'     : diam,
+                    }
+            hole_list.append(hole)
+        self.params['hole_list'].extend(hole_list)
+
+    def get_guide_plate_holes(self,hole_type='through'):
+        guide_x, guide_y, guide_z = self.params['guide_plate_dimensions']
+        hole_offset = self.params['guide_hole_offset']
+        if hole_type == 'through':
+            hole_diam = self.params['guide_thru_hole_diam']
+        else:
+            hole_diam = self.params['guide_tap_hole_diam']
+        hole_list = []
+        top_x, top_y, top_z = self.get_guide_plate_top_dim()
+        for i in (-1,1):
+            for j in (-1,1):
+                x_pos = i*(0.5*top_x - hole_offset)
+                y_pos = j*(0.5*top_y - hole_offset)
+                hole = (x_pos, y_pos, hole_diam)
+                hole_list.append(hole)
+        return hole_list
+
+    def get_guide_plate_top_dim(self):
+        guide_x, guide_y, guide_z = self.params['guide_plate_dimensions']
         top_x = guide_x
         top_y = 2*guide_y + self.params['capillary_diam']
         top_z = guide_z
-        self.guide_plate_top = Cube(size=(top_x,top_y,top_z))
+        return top_x, top_y, top_z
 
+    def make_led_pcb(self):
+        led_x, led_y, led_z = self.params['led_pcb_dimensions']
+        hole_list = self.get_led_holes(hole_type='through')
+        self.led_pcb = plate_w_holes(led_x, led_y, led_z, holes=hole_list)
 
+    def make_diffuser(self):
+        diff_x, diff_y, diff_z = self.params['diffuser_dimensions']
+        hole_list = self.get_led_holes(hole_type='through')
+        self.diffuser = plate_w_holes(diff_x, diff_y, diff_z, holes=hole_list)
+
+    def add_led_tap_holes(self):
+        hole_tuples = self.get_led_holes(hole_type='tap')
+        hole_list = []
+        for x,y,diam in hole_tuples:
+            hole = {
+                    'panel'    : 'top',
+                    'type'     : 'round',
+                    'location' : (x,y),
+                    'size'     : diam,
+                    }
+            hole_list.append(hole)
+        self.params['hole_list'].extend(hole_list)
+
+    def get_led_holes(self, hole_type='through'):
+        led_x, led_y, led_z = self.params['led_pcb_dimensions']
+        hole_offset = self.params['led_pcb_hole_offset']
+        if hole_type == 'through':
+            diam = self.params['led_pcb_thru_hole_diam']
+        else:
+            diam = self.params['led_pcb_tap_hole_diam']
+        hole_list = []
+        for i in (-1,1):
+            x_pos = i*(0.5*led_x - hole_offset)
+            y_pos = 0.5*led_y - hole_offset
+            hole = (x_pos, y_pos, diam)
+            hole_list.append(hole)
+        return hole_list
+
+    def make_led_standoffs(self):
+        height = self.params['diffuser_standoff_height']
+        diam = self.params['diffuser_standoff_diam']
+        radius = 0.5*diam
+        self.diffuser_standoff_pos = Cylinder(h=height,r1=radius,r2=radius)
+        self.diffuser_standoff_neg = Cylinder(h=height,r1=radius,r2=radius)
+
+
+
+
+
+

make_enclosure.py

 INCH2MM = 25.4
 
 # Inside dimensions
-x,y,z = 61.25, 45.0, 0.75*INCH2MM 
+x,y,z = 61.4, 45.0, 0.75*INCH2MM 
 hole_list = []
 
 params = {
         'inner_dimensions'                 : (x,y,z), 
         'wall_thickness'                   : 3.0, 
         'lid_radius'                       : 1.5,  
-        'top_x_overhang'                   : 1.0,
-        'top_y_overhang'                   : 1.0,
+        'top_x_overhang'                   : 1.5,
+        'top_y_overhang'                   : 1.5,
         'bottom_x_overhang'                : 8.0,
         'bottom_y_overhang'                : 3.0, 
         'lid2front_tabs'                   : (0.25,0.75),
         'capillary_hole_diam'              : 0.85,  
         'capillary_hole_offset'            : (0.25,0),
         'capillary_length'                 : 5*INCH2MM,
-        'rubber_band_notch_width'          : 2.0, 
-        'led_plate_xy'                     : (x-3.0,y-17.0),
-        'led_slot_xy'                      : (3.02,1.5), 
-        'led_standoff_diam'                : 0.25*INCH2MM,
-        'led_standoff_length'              : (1.0/4.0)*INCH2MM,
-        'led_num'                          : 10, 
-        'led_cable_hole_width'             : 3.0,
         'sensor_width'                     : 12.95,
         'sensor_length'                    : 61.33,
-        'diffuser_standoff_length'         : (1.0/4.0)*INCH2MM,
-        'diffuser_standoff_diam'           : 0.25*INCH2MM,
-        'diffuser_plate_xy'                : (x-3.0,y-17.0),
         'sensor_dimensions'                : (61.33,12.95,3.3),
         'sensor_hole_offset'               : 0.685,
-        'sensor_cable_hole_width'          : 5.0, 
-        'sensor_mount_hole_diam'           : 0.11*INCH2MM,
         'sensor_mount_hole_space'          : 57.40, 
-        'capillary_clamp_hole_space'       : 22.0,
-        'capillary_clamp_hole_diam'        : 0.11*INCH2MM,
-        'capillary_clamp_standoff_diam'    : 0.25*INCH2MM, 
-        'capillary_clamp_standoff_length'  : (5.0/32.0)*INCH2MM,
-        'capillary_clamp_plate_dimensions' : (6.35,28.35,1.5),
+        'sensor_mount_hole_diam'           : 0.11*INCH2MM, 
+        'led_pcb_dimensions'               : (61.0, 25.4, 1.7),
+        'led_pcb_thru_hole_diam'           : 0.0890*INCH2MM,
+        'led_pcb_tap_hole_diam'            : 0.0641*INCH2MM,
+        'led_pcb_hole_offset'              : 0.15*INCH2MM,
+        'diffuser_dimensions'              : (61.0 ,25.4, 1.5),
+        'diffuser_standoff_height'         : (7/32.0)*INCH2MM,
+        'diffuser_standoff_diam'           : (3/16.0)*INCH2MM,
         'hole_list'                        : hole_list,
         'guide_plate_dimensions'           : (x-0.2, 0.5*INCH2MM, 0.0625*INCH2MM),
+        'guide_thru_hole_diam'             : 0.0890*INCH2MM,
+        'guide_tap_hole_diam'              : 0.0641*INCH2MM,
+        'guide_hole_offset'                : 0.15*INCH2MM,
         }
 
 
         show_top=True,
         show_bottom=True, 
         show_front=True,
-        show_back=True,
-        show_left=True,
-        show_right=True,
-        show_led_plate=False,
-        show_diffuser_plate=False,
+        show_back=False,
+        show_left=False,
+        show_right=False,
         show_standoffs=True,
-        show_led_standoffs=False,
-        show_diffuser_standoffs=False,
         show_capillary=True,
         show_sensor=True,
-        show_clamp_plates=False,
-        show_clamp_standoffs=False,
-        show_guide_plate=True,
+        show_diffuser=True,
+        show_led_pcb=True,
+        show_guide_plates=True,
         explode=(0,0,0),
         )
 
 
 opaque_part_projection = enclosure.get_opaque_projection()
-diffuser_projection = enclosure.get_diffuser_projection()
 
 prog_assembly = SCAD_Prog()
 prog_assembly.fn = 50
 prog_assembly.add(part_assembly)
 prog_assembly.write('enclosure_assembly.scad')
 
-prog_opaque_projection = SCAD_Prog()
-prog_opaque_projection.fn = 50
-prog_opaque_projection.add(opaque_part_projection)
-prog_opaque_projection.write('enclosure_opaque_projection.scad')
-
-prog_diffuser_projection = SCAD_Prog()
-prog_diffuser_projection.fn = 50
-prog_diffuser_projection.add(diffuser_projection)
-prog_diffuser_projection.write('enclosure_diffuser_projection.scad')
+#prog_opaque_projection = SCAD_Prog()
+#prog_opaque_projection.fn = 50
+#prog_opaque_projection.add(opaque_part_projection)
+#prog_opaque_projection.write('enclosure_opaque_projection.scad')
+#
+#prog_diffuser_projection = SCAD_Prog()
+#prog_diffuser_projection.fn = 50
+#prog_diffuser_projection.add(diffuser_projection)
+#prog_diffuser_projection.write('enclosure_diffuser_projection.scad')
Tip: Filter by directory path e.g. /media app.js to search for public/media/app.js.
Tip: Use camelCasing e.g. ProjME to search for ProjectModifiedEvent.java.
Tip: Filter by extension type e.g. /repo .js to search for all .js files in the /repo directory.
Tip: Separate your search with spaces e.g. /ssh pom.xml to search for src/ssh/pom.xml.
Tip: Use ↑ and ↓ arrow keys to navigate and return to view the file.
Tip: You can also navigate files with Ctrl+j (next) and Ctrl+k (previous) and view the file with Ctrl+o.
Tip: You can also navigate files with Alt+j (next) and Alt+k (previous) and view the file with Alt+o.