Exemplo n.º 1
0
 def test_longer(self):
     ass = Assembly()
     ass.coalesce(np.array([[0., 0.], [2., 2.]]))
     labels = ass.coalesce(np.array([[1.9, 1.9], [3., 3.], [0.1, 0.1]]))
     self.assertTrue(np.array_equal(labels, [1, 2, 0]))
     self.assertTrue(
         np.array_equal(ass.points, [[0.1, 0.1], [1.9, 1.9], [3., 3.]]))
Exemplo n.º 2
0
    def __generate_assembly(self, instruction, n_id=""):
        if instruction in JUMP_OPS:
            commands = [
                """  CMP EAX, EBX""",
                f"""  CALL binop_{instruction.lower()}""",
                """  CMP EBX, False""", f"""  JE EXIT_{n_id}"""
            ]

        elif instruction in ARITHMETIC_OPS + LOGIC_OPS:
            if instruction == "IMUL" or instruction == "IDIV":
                if instruction == "IDIV":
                    Assembly.append("""  MOV EDX, 0""")
                commands = [f"""  {instruction} EBX""", """  MOV EBX, EAX"""]
            elif instruction == "SUB":
                commands = [
                    f"""  {instruction} EAX, EBX""", """  MOV EBX, EAX"""
                ]
            else:
                commands = f"""  {instruction} EBX, EAX"""

        elif instruction in STACK_OPS:
            if instruction == "PUSH":
                register = "EBX"
            elif instruction == "POP":
                register = "EAX"

            commands = f"""  {instruction} {register}"""

        Assembly.append(commands)
Exemplo n.º 3
0
    def eval(self, st):
        if self.children:
            result = self.children[0].eval(st)

        if self.value == "PLUS":
            if not isinstance(result, bool):
                return result

            raise ValueError(
                "Incompatible types: got \"Boolean\" expected \"Integer\"")

        elif self.value == "MINUS":
            Assembly.append("""  NEG EBX""")

            if not isinstance(result, bool):
                return -result

            raise ValueError(
                "Incompatible types: got \"Boolean\" expected \"Integer\"")

        elif self.value == "NOT":
            Assembly.append("""  NOT EBX""")

            if isinstance(result, bool):
                return not result
            else:
                return ~result
Exemplo n.º 4
0
    def eval(self, st):
        for child in self.children:
            if st.is_global:
                self.__generate_assembly(child.value, st.identifier)
            child.eval(st)

        if st.is_global:
            Assembly.append("""  res RESB 1""")
Exemplo n.º 5
0
 def eval(self, st):
     ass_mode = True
     if not ass_mode:
         print(self.children[0].eval(st))
     else:
         self.children[0].eval(st)
     Assembly.write_program(["PUSH EBX"])
     Assembly.write_program(["CALL print"])
Exemplo n.º 6
0
 def __init__(self, **kwargs):
     """
     Build a new OC instance
     """
     frame_size = kwargs.get('frame_size', 100)
     self.frame = deque([], frame_size)
     del kwargs['frame_size']
     self.algo = Batch(MCMC, **kwargs)
     self.ass = Assembly()
Exemplo n.º 7
0
def main():
    with open(sys.argv[1], 'r') as myfile:
        input_data = myfile.read().replace('\n', '')

    st = SymbolTable()
    Parser.tokens.origin = input_data
    result = Parser.init_parse()
    result.eval(st)
    Assembly.build_file()
    def __generate_assembly(self, instruction, n_id=""):
        if instruction == "BEFORE_ELSE":
            commands = [
                f"""  JMP FALSE_{n_id}""",
                f"""  EXIT_{n_id}:"""
            ]
        elif instruction == "AFTER_ELSE":
            commands = f"""  FALSE_{n_id}:"""

        Assembly.append(commands)
    def __generate_assembly(self, instruction):
        if instruction == "LOOP_ENTER":
            commands = f"""  WHILE_{self.identifier}:"""

        elif instruction == "LOOP_EXIT":
            commands = [
                f"""  JMP WHILE_{self.identifier}""",
                f"""  EXIT_{self.identifier}:"""
            ]

        Assembly.append(commands)
Exemplo n.º 10
0
    def eval(self, st):
        ass_mode = True
        if ass_mode:
            Assembly.write_program([f"LOOP_{self.identifier}:"])
            self.children[0].eval(st)
            Assembly.write_program([f"CMP EBX, False"])
            Assembly.write_program([f"JE EXIT_{self.identifier}"])
            self.children[1].eval(st)
            Assembly.write_program([f"JMP LOOP_{self.identifier}"])
            Assembly.write_program([f"EXIT_{self.identifier}:"])

        else:
            while self.children[0].eval(st) == True:
                self.children[1].eval(st)
Exemplo n.º 11
0
def create_cantilever(l, w):
    assem = Assembly(2)
    assem.rename_node(0, "gnd")
    assem.rename_node(1, "tip")
    layer = SOI_berk()

    assem.add_model(Anchor(1, 1, layer.p1), ["gnd"])
    assem.add_model(Beam2D(l, w, layer.p1), ["gnd", "tip"])
Exemplo n.º 12
0
 def test_coalesce(self):
     ass = Assembly()
     ass.coalesce(np.array([[0., 0.], [2., 2.]]))
     ass.coalesce(np.array([[1.9, 1.9], [3, 3], [0.1, 0.1]]))
     labels = ass.coalesce(np.array([[2.9, 2.9], [2.1, 2.1]]))
     self.assertTrue(np.array_equal(labels, [2, 1]))
     self.assertTrue(
         np.array_equal(ass.points, [[0.1, 0.1], [2.1, 2.1], [2.9, 2.9]]))
Exemplo n.º 13
0
class OC:
    """Wraps a mini batch MCMC algorithm"""
    def __init__(self, **kwargs):
        """
        Build a new OC instance
        """
        frame_size = kwargs.get('frame_size', 100)
        self.frame = deque([], frame_size)
        del kwargs['frame_size']
        self.algo = Batch(MCMC, **kwargs)
        self.ass = Assembly()

    def push_predict(self, points, columns):
        """
        push and predict data from the dataflow
        :param points: a chunk of data
        :param columns: the column names
        :return: the result that can be send to the dataviz server
        """
        arr = self._extend(points)
        self.algo.push(arr)
        centroids, labels = self.algo.predict(arr)
        return self._make_result(centroids, labels, columns)

    def _extend(self, points):
        """
        keep the given chunk in the fixed size frame. Old data can be reused
        if the chunk is smaller than the frame.
        :param points: a chunk of data
        :return: the content of the frame as a ndarray
        """
        self.frame.extend(points)
        return np.array(self.frame)

    def _make_result(self, centroids, labels, columns):
        """
        Build a result ready for the dataviz server. The result contains
        all known centers, even if empty for the current centroids
        :param centroids: the current centroids
        :param labels: the labels for the data in the frame
        :param columns: the column names
        :return: the result ready fo the dataviz server
        """
        indices = self.ass.coalesce(centroids)
        counts = np.zeros(len(self.ass.points))
        counts[indices] = np.bincount(labels)
        return {
            'centers': self.ass.points.tolist(),
            'counts': counts.tolist(),
            'columns': columns
        }

    def run(self):
        """Run the underlying algorithm"""
        return self.algo.run()
Exemplo n.º 14
0
def main():
    try:
        src_file = ARGS[1]
    except IndexError as e:
        sys.exit("Expecting pascal source file in position 1")

    try:
        exec_type = ARGS[2]
    except IndexError:
        exec_type = "i"

    Assembly.set_exec_type(exec_type)

    if exec_type in "ic":
        program = read_pascal(src_file).lower()
        Parser.parse(program).eval()
    else:
        sys.exit(f"Failed: expecting [i | c] in position 2 (got {exec_type})")

    if exec_type == "c":
        PATHS = get_paths(src_file)
        # Assembly.print()
        Assembly.make_file(PATHS["asm"])

        try:
            call(["nasm", "-f", "elf32", "-o", PATHS["obj"], PATHS["asm"]])
        except:
            sys.exit(f"Can't create object file from {PATHS['asm']}")

        try:
            call([
                "ld", "-m", "elf_i386", "-s", "-o", PATHS["exe"], PATHS["obj"]
            ])
        except:
            sys.exit(f"Can't create executable file from {PATHS['obj']}")

        call(["rm", f"{PATHS['asm']}", f"{PATHS['obj']}"])

        print(f"Done!\nExecutable: {PATHS['exe']}")
Exemplo n.º 15
0
    def __generate_assembly(self, op, n_id=""):
        if op in JUMP_OPS:
            commands = [
                """  CMP EAX, EBX""", f"""  CALL binop_{op.lower()}""",
                """  CMP EBX, False""", f"""  JE EXIT_{n_id}"""
            ]

        elif op in ARITHMETIC_OPS or op in LOGIC_OPS:
            if op == "IMUL" or op == "DIV":
                commands = [f"""  {op} EBX""", """  MOV EBX, EAX"""]
            elif op == "SUB":
                commands = [f"""  {op} EAX, EBX""", """  MOV EBX, EAX"""]
            else:
                commands = f"""  {op} EBX, EAX"""

        elif op in STACK_OPS:
            if op == "PUSH":
                register = "EBX"
            elif op == "POP":
                register = "EAX"

            commands = f"""  {op} {register}"""

        Assembly.append(commands)
Exemplo n.º 16
0
def genome_assembly(args):
    accession, fastq_dir, outdir = args
    contig_dir = Path(outdir, 'contig', accession)
    assembly = Assembly(accession=accession,
                        reads_path=fastq_dir,
                        outdir=outdir)
    assembly.denovo()
    assembly.move_contig(contig_dir)
    shutil.rmtree(fastq_dir)
    shutil.rmtree(assembly.outdir)
    return accession, contig_dir, outdir
    def eval(self, st):

        condition = self.children[0]
        true_stmts = self.children[1]
        false_stmts = self.children[2]

        if Assembly.get_exec_type() == "i":
            if condition.eval(st, n_id=self.identifier):
                true_stmts.eval(st)
            else:
                false_stmts.eval(st)

        else:
            condition.eval(st, n_id=self.identifier)
            true_stmts.eval(st)
            self.__generate_assembly("BEFORE_ELSE", n_id=self.identifier)
            false_stmts.eval(st)
            self.__generate_assembly("AFTER_ELSE", n_id=self.identifier)
Exemplo n.º 18
0
    def main(self):
        printwithtime("Welcome to the metassembler.")
        self.process_arguments()
        self.check_input()
        self.get_delta()
        self.process_delta()
        self.contigs_from_fasta()
        self.contigs_from_alignments() # TODO: these two methods should be merged?

        if self.process_indels_bool: self.process_indels()

        self.get_all_neighbors()
        if self.perform_assembly_bool:
            self.assemble()
        else:
            for contig in self.contigs.values(): self.assemblies[contig.name] = Assembly([contig])
        
        for assembly in self.assemblies.values():
            assembly.get_sequence()
        self.cleanup()
        self.summary()
        self.write_output()
        printwithtime("Done.")
Exemplo n.º 19
0
ie: 'export ASSEMBLY_APP=default'

## ASSEMBLY_ENV
By default, Assembly will attempt to load the 'Development' config object from './config.py'
To specify a different environment, set the environment variable 'ASSEMEBLY_ENV'
to the environment class name 
ie: 'export ASSEMBLY_ENV=Production'
"""
"""
Import the base Assembly
"""
from assembly import Assembly
"""
If you want to use your views CLI, you can import them below
"""
import main.cli
"""
APPS = {}
a dict with list of applications to load by name
You can add as many views as you want per application.
Set the environment variable 'ASSEMBLY_APP' to the name of the app to use
ie: 'export ASSEMBLY_APP=default'
"""

APPS = {"default": ["main"]}
"""
Initialize the application
the 'app' variable is required
"""
app = Assembly.init(__name__, APPS)
Exemplo n.º 20
0
def parse_legacy(obj,mymodel):
    """
    take a loaded legacy dictionary, decides between current filetype and legacy caDNAno 1.0 filetype
    
    Parameters
    ----------
    obj: dictionary object generated from a JSON file 

    See Also
    --------

    Examples
    -------- 
    """
    from assembly import Assembly
    from part import Part
    
    my_assembly = Assembly()
    
    my_part = Part(my_assembly.createPartID())
    
    
    vhelixlist = obj["vstrands"] # should rename to 
    name = obj["name"] # placeholder, not really used
    
    # create dictionaries (keyed by vstrand #) of
    # row/col, scaf array, stap array
    vhToRowCol = {}
    vhToScaf = {}
    vhToStap = {}
    vhNums = []
    
    for helix in vhelixlist: # strand should be helix
        num = helix["num"] # helix number
        vhNums.append(num) # keep track of a list of helix numbers
        row = helix["row"] # slice row for this helix
        col = helix["col"] # slice column
        scaf = helix["scaf"] # array of scaffold points
        stap = helix["stap"] # array of staple pointers
        vhToRowCol[num] = [row,col]
        vhToScaf[num] = scaf
        vhToStap[num] = stap
    
    # extract scaffold 5' breakpoints
    scafBreaks = []
    for vh in vhNums:
        scaf = vhToScaf[vh]
        for i in range(len(scaf)):
            base = scaf[i]
            if (base[1] == -1) & (base[3] != -1):
                scafBreaks.append([vh, i])
    
    # extract staple 5' breakpoints
    stapBreaks = []
    for vh in vhNums:
        stap = vhToStap[vh]
        for i in range(len(stap)):
            base = stap[i]
            if (base[1] == -1) & (base[3] != -1):
                stapBreaks.append([vh, i])
    
    
    # extract scaffold paths, starting at 5' breakpoints
    scafPaths = []
    for scafBreak in scafBreaks:
        path = []
        [curr_vh, curr_base] = scafBreak
        [next_vh, next_base] = vhToScaf[curr_vh][curr_base][2:4]
        while next_base != -1:
            [row, col] = vsToRowCol[curr_vs]
            [x, y, z] = getScafCoord(row,col,curr_base)
            path.append([curr_vs,curr_base,[x, y, z]])
            # append midpoint for crossover
            if (curr_vs != next_vs) & (curr_base == next_base):
                (x1,y1,z1) = getScafCoord(row,col,curr_base)
                [nextrow, nextcol] = vsToRowCol[next_vs]
                (x2,y2,z2) = getScafCoord(nextrow,nextcol,next_base)
                midxyz = [(x1+x2)/2,(y1+y2)/2,(z1+z2)/2]
                path.append([curr_vs,curr_base,midxyz])
            [curr_vs, curr_base] = [next_vs, next_base]
            [next_vs, next_base] = vsToScaf[curr_vs][curr_base][2:4]
        [row, col] = vsToRowCol[curr_vs]
        [x, y, z] = getScafCoord(row,col,curr_base)
        path.append([curr_vs,curr_base,[x, y, z]])
        scafPaths.append(path)
    
    
    # extract staple paths, starting at 5' breakpoints
    stapPaths = []
    for stapBreak in stapBreaks:
        path = []
        [curr_vs, curr_base] = stapBreak
        [next_vs, next_base] = vsToStap[curr_vs][curr_base][2:4]
        while next_base != -1:
            [row, col] = vsToRowCol[curr_vs]
            [x, y, z] = getStapCoord(row,col,curr_base)
            path.append([curr_vs,curr_base, [x, y, z]])
            # append midpoint for crossover
            if (curr_vs != next_vs) & (curr_base == next_base):
                (x1,y1,z1) = getStapCoord(row,col,curr_base)
                [nextrow, nextcol] = vsToRowCol[next_vs]
                (x2,y2,z2) = getStapCoord(nextrow,nextcol,next_base)
                midxyz = [(x1+x2)/2,(y1+y2)/2,(z1+z2)/2]
                path.append([curr_vs,curr_base,midxyz])
            [curr_vs, curr_base] = [next_vs, next_base]
            [next_vs, next_base] = vsToStap[curr_vs][curr_base][2:4]
        [row, col] = vsToRowCol[curr_vs]
        [x, y, z] = getStapCoord(row,col,curr_base)
        path.append([curr_vs,curr_base, [x, y, z]])
        stapPaths.append(path)
    
    my_part.VHelix = vhelixlist
    my_assembly.addPart(my_part)
    return my_parts, my_assembly
Exemplo n.º 21
0
    def assemble(self):
        printwithtime("Assembling contigs...")
        
        contigs_copy = self.contigs.copy()
        
        # greedily finds "anchor" contigs (with no neighbors on one side)
        for key, contig in self.contigs.items():
            if contig.left == [None] or contig.right == [None]:
                index = len(self.assemblies)
                assembly = Assembly([contig])
                assembly.left  = contig.left
                assembly.right = contig.right
                self.assemblies[index] = assembly
                del(contigs_copy[key])
                print("Assigning %s to assembly %i // %i contigs remaining to assign") % (key, index, len(contigs_copy))
        
        self.contigs = contigs_copy

        num_contigs_list = [None, None]
        while contigs_copy != {}:
            if num_contigs_list[0] == num_contigs_list[1] != None:
                break
            else:
                for index, assembly in self.assemblies.items():
                    for key, contig in self.contigs.items():
                        if assembly.assembly[-1] in contig.left:
                            if len(assembly.right) == 1 and len(contig.left) == 1:                        
                                assembly.assembly.append(contig)
                                assembly.right = contig.right 
                                del(contigs_copy[key])
                                print("Assigning %s to assembly %i // %i contigs remaining to assign") % (key, index, len(contigs_copy))
                        elif assembly.assembly[0] in contig.right:
                            if len(assembly.left) == 1 and len(contig.right) == 1:                            
                                assembly.assembly.insert(0, contig)
                                assembly.left = contig.left
                                del(contigs_copy[key])
                                print("Assigning %s to assembly %i // %i contigs remaining to assign") % (key, index, len(contigs_copy))
                num_contigs_list[0] = num_contigs_list[1]
                num_contigs_list[1] = len(contigs_copy)

# TODO: list value of xrange(100) [1st pass, 2nd pass...]
# TODO: make it more clear when it enters this phase

####### handle any unassigned contigs
        if contigs_copy != {}:
            printwithtime("Assigning unassignable contigs")
            index = int(max(self.assemblies.keys())) # ensures that nothing is being overwritten
            # TODO: add a try/except loop that double-checks nothing is being overwritten
            for key, contig in self.contigs.items():
                index += 1
                self.assemblies[index] = Assembly([contig], contig.left, contig.right)
                del(contigs_copy[key])
                print("Assigning %s to assembly %i // %i contigs remaining to assign") % (key, index, len(contigs_copy))

####### merging assemblies
# TODO: current issue, sometimes combines one assembly into multiple places...
        printwithtime("Merging assemblies...")
        num_merges = 0
        assemblies_copy = self.assemblies.copy()
        for asmb1 in assemblies_copy.items():
            for asmb2 in assemblies_copy.items():
                if asmb1 != asmb2 and asmb1 in self.assemblies.items():
                    # the and clause helps ensure that assemblies are not merged into
                    # assemblies that no longer exist
                    asmb1_index = asmb1[0]
                    asmb1_asmb  = asmb1[1]
                    asmb2_index = asmb2[0]
                    asmb2_asmb  = asmb2[1]

                    if (asmb2_asmb.assembly[0] in asmb1_asmb.right and asmb1_asmb.right != [None] and asmb2_asmb.left != [None]) or \
                        (asmb1_asmb.assembly[-1] in asmb2_asmb.left and asmb2_asmb.left != [None] and asmb1_asmb.right != [None]):
                        if len(asmb1_asmb.right) == 1 and len(asmb2_asmb.left) == 1:
                            print("Merging assembly %s into assembly %s") % (asmb2_index, asmb1_index)
  #                          print("Old assemblies: %s and %s") % (asmb1_asmb, asmb2_asmb)
                            asmb1_asmb.assembly.extend(asmb2_asmb.assembly)
  #                          print("New assembly: %i  %s") % (asmb1_index, asmb1_asmb)
                            asmb1_asmb.right = asmb2_asmb.right
                            num_merges += 1
                            try:
                                del(assemblies_copy[asmb2_index])
                                del(self.assemblies[asmb2_index])
                            except:
                                printwithtime("exception!")
   #                         printwithtime("---")                            


                    elif (asmb1_asmb.assembly[0] in asmb2_asmb.right and asmb2_asmb.right != [None] and asmb1_asmb.left != [None]) or \
                        (asmb2_asmb.assembly[-1] in asmb1_asmb.left and asmb1_asmb.left != [None] and asmb2_asmb.right != [None]):
                        if len(asmb2_asmb.right) == 1 and len(asmb1_asmb.left) == 1:
                            print("Merging assembly %s into assembly %s") % (asmb1_index, asmb2_index)
 #                           print("Old assemblies: %s and %s") % (asmb1_asmb, asmb2_asmb)
                            asmb2_asmb.assembly.extend(asmb1_asmb.assembly)
 #                           print("New assembly: %i  %s") % (asmb1_index, asmb2_asmb)
                            asmb2_asmb.right = asmb1_asmb.right
                            num_merges += 1
                            try:
                                del(assemblies_copy[asmb1_index])
                                del(self.assemblies[asmb1_index])
                            except:
                                printwithtime("exception!")
    #                            printwithtime(asmb1_asmb, asmb1_index, asmb1_asmb.left, asmb1_asmb.right
    #                            printwithtime(asmb2, asmb2_index, asmb2_asmb.left, asmb2_asmb.right
    #                        printwithtime("---"
        print("%i merges made.") % (num_merges)
Exemplo n.º 22
0
import os
from assembly import Assembly
from assembly.rhino import AssemblyArtist

HERE = os.path.dirname(__file__)
DATA = os.path.abspath(os.path.join(HERE, "data"))

filepath = os.path.join(DATA, 'flemish_bond.json')
assembly = Assembly.from_json(filepath)

artist = AssemblyArtist(assembly, layer='COMPAS::Assembly')
artist.clear_layer()
artist.draw()
Exemplo n.º 23
0
    from evaluation import Evaluator
    

    k=10
    circle=Arc(0,0,0,2*numpy.pi,.5)
    circle2=Arc(2,0,0,2*numpy.pi,.5)
    d=Domain([circle])
    d2=Domain([circle2])
    mesh=Mesh([d,d2])
    mesh.discretize(50)
    quadrule=GaussQuadrature(5,3,0.15)
    #mToB=Legendre.legendreBasis(mesh,0)
    mToB=NodalLin.nodalLinBasis(mesh)
    kernel=AcousticDoubleLayer(k)

    assembly=Assembly(mToB,quadrule)
    mKernel=assembly.getKernel(kernel)
    mIdentity=assembly.getIdentity()
    op=mIdentity+2*mKernel
    rhs=assembly.projFun([lambda t,x,normals: -numpy.exp(1j*k*x[0])])

    coeffs=numpy.linalg.solve(.5*mIdentity+mKernel,rhs)
    plotBndFun(mToB,coeffs[:,0])
    ev=Evaluator(mToB,kernel,quadrule)
    v=Visualizer(ev,[-1.5,3.5,-1,3],100,100,incWave=lambda x: numpy.exp(1j*k*x[0]))
    v.fullField(coeffs[:,0])
    v.show()



 
Exemplo n.º 24
0
 def test_init(self):
     ass = Assembly()
     labels = ass.coalesce(np.array([[0., 0.], [2., 2.]]))
     self.assertTrue(np.array_equal(labels, [0, 1]))
Exemplo n.º 25
0
 def test_shorter(self):
     ass = Assembly()
     ass.coalesce(np.array([[0., 0.], [2., 2.]]))
     labels = ass.coalesce(np.array([[1.9, 1.9]]))
     self.assertTrue(np.array_equal(labels, [1]))
     self.assertTrue(np.array_equal(ass.points, [[0., 0.], [1.9, 1.9]]))
Exemplo n.º 26
0
 def __generate_assembly(self, var_name, st_id):
     Assembly.append(f"""  {var_name}_{st_id} RESD 1""")
Exemplo n.º 27
0
width, length, height = data['brick_dimensions']

# little tolerance to not 'crash' into collision objects
tolerance_vector = Vector.from_data(data['tolerance_vector'])

savelevel_vector = Vector.from_data(data['savelevel_vector'])

# define target frame
target_frame = Frame([-0.26, -0.28, height], [1, 0, 0], [0, 1, 0])
target_frame.point += tolerance_vector

# create Element and move it to target frame
element = Element.from_data(data['brick'])

# create Assembly with element at target_frame
assembly = Assembly()
T = Transformation.from_frame_to_frame(element.frame, target_frame)
assembly.add_element(element.transformed(T))

# Bring the element's mesh into the robot's tool0 frame
element_tool0 = element.copy()
T = Transformation.from_frame_to_frame(element_tool0.gripping_frame,
                                       tool.frame)
element_tool0.transform(T)

# define picking_configuration
picking_configuration = Configuration.from_data(data['picking_configuration'])

# define picking frame
picking_frame = Frame.from_data(data['picking_frame'])
picking_frame.point += tolerance_vector
savelevel_picking_frame = picking_frame.copy()
savelevel_picking_frame.point += savelevel_vector
picking_frame.point += tolerance_vector

# create tool from json
filepath = os.path.join(DATA, "vacuum_gripper.json")
tool = Tool.from_json(filepath)

# load assembly from file
filepath = os.path.join(DATA, '048_flemish_bond.json')
# load from existing if calculation failed at one point...

clear_planning_scene = True

if os.path.isfile(PATH_TO):
    assembly = Assembly.from_json(PATH_TO)
    clear_planning_scene = False
else:
    assembly = Assembly.from_json(filepath)

# create an attached collision mesh to be attached to the robot's end effector.
T = Transformation.from_frame_to_frame(brick.gripping_frame, tool.frame)
brick_tool0 = brick.transformed(T)
attached_brick_mesh = AttachedCollisionMesh(
    CollisionMesh(brick_tool0.mesh, 'brick'), 'ee_link')

# ==============================================================================
# From here on: fill in code, whereever you see this dots ...


def plan_picking_motion(robot, picking_frame, savelevel_picking_frame,
# The name of the json file to save the assembly into
PATH_TO = os.path.join(
    DATA,
    os.path.splitext(os.path.basename(__file__))[0] + ".json")

# Load assembly settings
settings_file = os.path.join(DATA, "settings.json")
with open(settings_file, 'r') as f:
    data = json.load(f)

brick = Element.from_data(data['brick'])
halfbrick = Element.from_data(data['halfbrick'])
width, length, height = data['brick_dimensions']

# Create assembly
assembly = Assembly()

# ==============================================================================
# Your code goes here.
# HINT: Use the examples to see how to re-use the brick/halfbrick elements
# defined above, and get a transformed instance of each of them as you
# build up your brick wall.
# Your code comes here

# ==============================================================================

# Transform assembly to correct location and adjust if needed
assembly.transform(Translation([-0.26, -0.34, 0]))

# Save assembly to json
assembly.to_json(PATH_TO, pretty=True)
Exemplo n.º 30
0
 def __generate_assembly(self, value, st_id):
     Assembly.append(f"""  MOV EBX, [{value}_{st_id}]""")
Exemplo n.º 31
0
with open(settings_file, 'r') as f:
    data = json.load(f)

# Get from settings
# Get from settings
brick = Element.from_data(data['brick'])
halfbrick = Element.from_data(data['halfbrick'])
width, length, height = data['brick_dimensions']

COURSES = 3
BRICKS_PER_COURSE = 5

MORTAR_PERPENDS = 0.003
MORTAR_BEDS = 0.003

assembly = Assembly()

total_length = BRICKS_PER_COURSE * width + (BRICKS_PER_COURSE -
                                            1) * MORTAR_PERPENDS
gap_even = MORTAR_PERPENDS
gap_uneven = (total_length - (BRICKS_PER_COURSE * width)) / BRICKS_PER_COURSE

for row in range(COURSES):

    dy = row * height
    half_brick_ends = row % 2 != 0
    gap = gap_even if row % 2 == 0 else gap_uneven
    dx = 0

    bricks_in_course = BRICKS_PER_COURSE + (1 if half_brick_ends else 0)
    for j in range(bricks_in_course):
Exemplo n.º 32
0
    root_logger = logging.getLogger()
    root_logger.addHandler(console_handler)
    root_logger.setLevel(logging.DEBUG)

if __name__ == "__main__":
    setup_logging()
    args = docopt(__doc__)

    if args["load"]:
        with open(args["<filename>"], 'r') as f:
            pprint.pprint(load(f))
    elif args["parse"]:
        plan = Plan.from_file(args["<filename>"])
        print plan
    elif args["process"]:
        assembly = Assembly.from_plan(args["<filename>"])
        print assembly

    elif args["generate"]:
        assembly = Assembly.from_plan(args["<filename>"])
        assembly.generate_files(os.path.split(args["<filename>"])[0], args["<output_folder>"])
    elif args["generun"]:
        assembly = Assembly.from_plan(args["<filename>"])
        assembly.generate_files(os.path.split(args["<filename>"])[0], args["<output_folder>"])
        os.chdir(os.path.join(args["<output_folder>"], assembly.plan.name))
        client = Client(docker_url())
        assembly.run(client)
    elif args["start"]:
        assembly = Assembly.from_plan(args["<filename>"])
        client = Client(docker_url())
        assembly.start(client)
Exemplo n.º 33
0
	def eval(self, st):
		res = st.get_var(self.value)
		Assembly.write_program([f"MOV EBX, [{self.value}_{res[1]}]"])
		return res[0]