def add_pattens_to_raster()

in src/spg/spg.py [0:0]

• 47 lines of code
• 18 McCabe index (conditional complexity)

    def add_pattens_to_raster(self, per_wall_results):
        """ Takes all the results from the pattern generators, and processes them into the valid raster
        maps for each of the processors

        :param per_wall_results: dict of results data from generate patterns method
        """
        generator_changes_per_frame_threads = []
        generator_threads = []
        replicator_threads = []
        results = {}
        count = 0
        for raster_name, raster_map in self.rasters.items():
            self.status = "Generating Raster: " + raster_name
            yield self.progress()
            results[raster_name] = {}
            base_path = self.get_raster_base_path(raster_name)

            if not os.path.exists(base_path):
                os.makedirs(base_path)

            start_frame_offset = self.project_settings.sequence_start_frame
            for pattern_generator, pattern_results in per_wall_results.items():
                first_pattern_frame = True
                first_pattern_sequence_frame = 0
                for frame in range(int(pattern_generator.sequence_length * self.project_settings.frame_rate)):
                    full_sequence_frame_num = start_frame_offset

                    kwargs = {
                        "full_sequence_frame_num": full_sequence_frame_num,
                        "raster_map": raster_map,
                        "pattern_results": pattern_results
                    }

                    # If we are the first frame of a pattern we stitch it
                    # If we are also a none fixed pattern we stitch it (ie every frame)
                    generator_changes_per_frame = pattern_generator.method != _constants.GM_FIXED
                    if first_pattern_frame or generator_changes_per_frame:
                        # We create a new thread which executes our generator, which we start and keep track of
                        first_pattern_sequence_frame = full_sequence_frame_num
                        thread = _ThreadedFunction(self.stitch_raster_frame, frame, kwargs, results)
                        thread.start()
                        if generator_changes_per_frame:
                            generator_changes_per_frame_threads.append(thread)
                        else:
                            generator_threads.append(thread)
                    else:
                        # If we are not the first frame and not a fixed pattern we replicate the first frame
                        kwargs["first_pattern_sequence_frame"] = first_pattern_sequence_frame
                        thread = _ThreadedFunction(self.replicate_stitch_raster_frame, frame, kwargs, results)
                        replicator_threads.append(thread)

                    first_pattern_frame = False
                    start_frame_offset += 1

            count += 1

        # We wait for all the generator threads to complete first
        [thread.join() for thread in generator_threads]

        # We start the replicator threads and wait for them to all finish
        [thread.start() for thread in replicator_threads]
        [thread.join() for thread in replicator_threads]

        # Finally we wait for all the per frame generators to finish stitching
        [thread.join() for thread in generator_changes_per_frame_threads]

        self.completed_tasks += count

        yield self.progress()
        return results