Python BufferUtils.logical_to_index方法代码示例

# 需要导入模块: from lib.buffer_utils import BufferUtils [as 别名]
# 或者: from lib.buffer_utils.BufferUtils import logical_to_index [as 别名]
    def get_pixel_neighbors(self, index):
        """
        Returns a list of pixel addresses that are adjacent to the given address.
        """

        neighbors = self._pixel_neighbors_cache.get(index, None)

        if neighbors is None:
            neighbors = []
            strand, address, pixel = BufferUtils.index_to_logical(index)
            f = self.fixture(strand, address)
            neighbors = [BufferUtils.logical_to_index((strand, address, p)) for p in f.pixel_neighbors(pixel)]

            if (pixel == 0) or (pixel == f.pixels - 1):
                # If this pixel is on the end of a fixture, consider the neighboring fixtures
                loc = 'end'
                if pixel == 0:
                    loc = 'start'

                logical_neighbors = self.get_colliding_fixtures(strand, address, loc)
                neighbors += [BufferUtils.logical_to_index(n) for n in logical_neighbors]

            self._pixel_neighbors_cache[index] = neighbors

        return neighbors

# 需要导入模块: from lib.buffer_utils import BufferUtils [as 别名]
# 或者: from lib.buffer_utils.BufferUtils import logical_to_index [as 别名]
    def render_command_list(self, list, buffer):
        """
        Renders the output of a command list to the output buffer.
        Commands are rendered in FIFO overlap style.  Run the list through
        filter_and_sort_commands() beforehand.
        If the output buffer is not zero (black) at a command's target,
        the output will be additively blended according to the blend_state
        (0.0 = 100% original, 1.0 = 100% new)
        """
        for command in list:
            color = command.get_color()
            if isinstance(command, SetAll):
                buffer[:,:] = color

            elif isinstance(command, SetStrand):
                strand = command.get_strand()
                start, end = BufferUtils.get_strand_extents(strand)
                buffer[start:end] = color

            elif isinstance(command, SetFixture):
                strand = command.get_strand()
                fixture = command.get_address()
                start = BufferUtils.logical_to_index((strand, fixture, 0))
                end = start + self._scene.fixture(strand, fixture).pixels
                buffer[start:end] = color

            elif isinstance(command, SetPixel):
                strand = command.get_strand()
                fixture = command.get_address()
                offset = command.get_pixel()
                pixel = BufferUtils.logical_to_index((strand, fixture, offset))
                buffer[pixel] = color

# 需要导入模块: from lib.buffer_utils import BufferUtils [as 别名]
# 或者: from lib.buffer_utils.BufferUtils import logical_to_index [as 别名]
    def get_fixture_bounding_box(self):
        """
        Returns the bounding box containing all fixtures in the scene
        Return value is a tuple of (xmin, ymin, xmax, ymax)
        """
        xmin = 999999
        xmax = -999999
        ymin = 999999
        ymax = -999999

        fh = self.fixture_hierarchy()
        for strand in fh:
            for fixture in fh[strand]:
                for pixel in range(self.fixture(strand, fixture).pixels):
                    x, y = self.get_pixel_location(BufferUtils.logical_to_index((strand, fixture, pixel)))
                    if x < xmin:
                        xmin = x
                    if x > xmax:
                        xmax = x
                    if y < ymin:
                        ymin = y
                    if y > ymax:
                        ymax = y

        return (xmin, ymin, xmax, ymax)

# 需要导入模块: from lib.buffer_utils import BufferUtils [as 别名]
# 或者: from lib.buffer_utils.BufferUtils import logical_to_index [as 别名]
    def warmup(self):
        """
        Warms up caches
        """
        log.info("Warming up scene caches...")
        fh = self.fixture_hierarchy()
        for strand in fh:
            for fixture in fh[strand]:
                self.get_colliding_fixtures(strand, fixture)
                for pixel in range(self.fixture(strand, fixture).pixels):
                    index = BufferUtils.logical_to_index((strand, fixture, pixel))
                    neighbors = self.get_pixel_neighbors(index)
                    self.get_pixel_location(index)
                    for neighbor in neighbors:
                        self.get_pixel_distance(index, neighbor)
        self.get_fixture_bounding_box()
        self.get_intersection_points()
        self.get_all_pixels_logical()
        self._tree = spatial.KDTree(self.get_all_pixel_locations())

        locations = self.get_all_pixel_locations()
        self.pixelDistances = np.empty([len(locations), len(locations)])

        for pixel in range(len(locations)):
            cx, cy = locations[pixel]
            x,y = (locations - (cx, cy)).T
            pixel_distances = np.sqrt(np.square(x) + np.square(y))
            self.pixelDistances[pixel] = pixel_distances

        log.info("Done")

# 需要导入模块: from lib.buffer_utils import BufferUtils [as 别名]
# 或者: from lib.buffer_utils.BufferUtils import logical_to_index [as 别名]
    def get_all_pixels(self):
        """
        Returns a list of all pixels in buffer address format (strand, offset)
        """
        if self._all_pixels_raw is None:
            all_pixels = []
            for s, a, p in self.get_all_pixels_logical():
                #pxs.append(BufferUtils.get_buffer_address((s, a, p), scene=self))
                all_pixels.append(BufferUtils.logical_to_index((s, a, p), scene=self))
            all_pixels = sorted(all_pixels)
            self._all_pixels_raw = all_pixels

        return self._all_pixels_raw

# 需要导入模块: from lib.buffer_utils import BufferUtils [as 别名]
# 或者: from lib.buffer_utils.BufferUtils import logical_to_index [as 别名]
 def warmup(self):
     """
     Warms up caches
     """
     log.info("Warming up scene caches...")
     fh = self.fixture_hierarchy()
     for strand in fh:
         for fixture in fh[strand]:
             self.get_colliding_fixtures(strand, fixture)
             for pixel in range(self.fixture(strand, fixture).pixels):
                 index = BufferUtils.logical_to_index((strand, fixture, pixel))
                 neighbors = self.get_pixel_neighbors(index)
                 self.get_pixel_location(index)
                 for neighbor in neighbors:
                     self.get_pixel_distance(index, neighbor)
     self.get_fixture_bounding_box()
     self.get_intersection_points()
     self.get_all_pixels_logical()
     #self.get_all_pixels()
     #self.get_all_pixel_locations()
     log.info("Done")

# 需要导入模块: from lib.buffer_utils import BufferUtils [as 别名]
# 或者: from lib.buffer_utils.BufferUtils import logical_to_index [as 别名]
    def draw(self, dt):
        self._hue = (self._hue + (dt * 0.1)) % 1.0
        self.setAllHLS(self._hue, 0.2, 1.0)
        for strand in self._heirarchy:
            self.setPixelHLS(BufferUtils.logical_to_index((strand, 0, 0), scene=self.scene()), (0.33, 0.5, 1.0))

            if (strand & 0x8):
                self.setPixelHLS(BufferUtils.logical_to_index((strand, 0, 1), scene=self.scene()), (0.66, 0.9, 1.0))
            else:
                self.setPixelHLS(BufferUtils.logical_to_index((strand, 0, 1), scene=self.scene()), (0.0, 0.2, 0.0))
            if (strand & 0x4):
                self.setPixelHLS(BufferUtils.logical_to_index((strand, 0, 2), scene=self.scene()), (0.66, 0.9, 1.0))
            else:
                self.setPixelHLS(BufferUtils.logical_to_index((strand, 0, 2), scene=self.scene()), (0.0, 0.2, 0.0))
            if (strand & 0x2):
                self.setPixelHLS(BufferUtils.logical_to_index((strand, 0, 3), scene=self.scene()), (0.66, 0.9, 1.0))
            else:
                self.setPixelHLS(BufferUtils.logical_to_index((strand, 0, 3), scene=self.scene()), (0.0, 0.2, 0.0))
            if (strand & 0x1):
                self.setPixelHLS(BufferUtils.logical_to_index((strand, 0, 4), scene=self.scene()), (0.66, 0.9, 1.0))
            else:
                self.setPixelHLS(BufferUtils.logical_to_index((strand, 0, 4), scene=self.scene()), (0.0, 0.2, 0.0))

            for fixture in self._heirarchy[strand]:
                last_fixture_pixel = self._heirarchy[strand][fixture].pixels - 1
                self.setPixelHLS(BufferUtils.logical_to_index((strand, fixture, last_fixture_pixel), scene=self.scene()), (0.66, 0.5, 1.0))
                if fixture > 0:
                    self.setPixelHLS(BufferUtils.logical_to_index((strand, fixture, 0), scene=self.scene()), (0.15, 0.5, 1.0))

            last_fixture = len(self._heirarchy[strand].keys()) - 1
            last_pixel = self._heirarchy[strand][last_fixture].pixels - 1

            self.setPixelHLS(BufferUtils.logical_to_index((strand, last_fixture, last_pixel), scene=self.scene()), (0.0, 0.5, 1.0))

# 需要导入模块: from lib.buffer_utils import BufferUtils [as 别名]
# 或者: from lib.buffer_utils.BufferUtils import logical_to_index [as 别名]
    def draw(self, dt):

        self._current_time += dt
        self._mass_destruction_countdown -= dt
    
        # Ensure that empty displays start up with some seeds
        p_birth = (1.0 - self._spontaneous_birth_probability) if self._population > 5 else 0.5

        # Spontaneous birth: Rare after startup
        if (self._population < self._population_limit) and random.random() + self.parameter('audio-onset-birth-boost').get() > p_birth:
            strand = random.randint(0, BufferUtils.num_strands - 1)
            fixture = random.randint(0, BufferUtils.strand_num_fixtures(strand) - 1)
            pixel = random.randint(0, BufferUtils.fixture_length(strand, fixture) - 1)
            address = BufferUtils.logical_to_index((strand, fixture, pixel))
            if address not in (self._growing + self._alive + self._dying + self._fading_out):
                self._growing.append(address)
                self._time[address] = self._current_time
                self._population += 1

        self._spread_boost *= self.parameter('audio-onset-spread-boost-echo').get()
        if self._mixer.is_onset():
            self._spread_boost += self.parameter('audio-onset-spread-boost').get()

        # Color growth
        for address in self._growing:
            neighbors = self.scene().get_pixel_neighbors(address)
            p, color = self._get_next_color(address, self._growth_time, self._current_time)
            if p >= 1.0:
                self._growing.remove(address)
                self._alive.append(address)
                self._time[address] = self._current_time
            self.setPixelHLS(address, color)

            # Spread
            spread_rate = self._spread_rate + self._spread_boost

            if (self._population < self._population_limit) and (random.random() < spread_rate * dt):
                for spread in neighbors:
                    if spread not in (self._growing + self._alive + self._dying + self._fading_out):
                        self._growing.append(spread)
                        self._time[spread] = self._current_time
                        self._population += 1

        # Lifetime
        for address in self._alive:
            neighbors = self.scene().get_pixel_neighbors(address)
            live_neighbors = [i for i in neighbors if i in self._alive]
            lt = self._life_time
            if len(neighbors) < 2:
                lt = self._isolated_life_time

            if len(live_neighbors) < 3 and ((self._current_time - self._time[address]) / lt) >= 1.0:
                self._alive.remove(address)
                self._dying.append(address)
                self._time[address] = self._current_time
                self._population -= 1

            self.setPixelHLS(address, self._alive_color)

            # Spread
            if (self._population < self._population_limit) and random.random() < self._birth_rate * dt:
                for spread in neighbors:
                    if spread not in (self._growing + self._alive + self._dying + self._fading_out):
                        self._growing.append(spread)
                        self._time[spread] = self._current_time
                        self._population += 1

        # Color decay
        for address in self._dying:
            p, color = self._get_next_color(address, self._death_time, self._current_time + self.parameter('audio-onset-death-boost').get())
            if p >= 1.0:
                self._dying.remove(address)
                self._fading_out.append(address)
                self._time[address] = self._current_time
            self.setPixelHLS(address, color)

        # Fade out
        for address in self._fading_out:
            p, color = self._get_next_color(address, self._fade_out_time, self._current_time + self.parameter('audio-onset-death-boost').get())
            if p >= 1.0:
                self._fading_out.remove(address)
            self.setPixelHLS(address, color)

        # Mass destruction
        if (self._population == self._population_limit) or \
                (self._population > self._mass_destruction_threshold and self._mass_destruction_countdown <= 0):
            for i in self._alive:
                if random.random() > 0.95:
                    self._alive.remove(i)
                    self._dying.append(i)
                    self._population -= 1
            for i in self._growing:
                if random.random() > 0.85:
                    self._growing.remove(i)
                    self._dying.append(i)
                    self._population -= 1
            self._mass_destruction_countdown = self.parameter('mass-destruction-time').get()

# 需要导入模块: from lib.buffer_utils import BufferUtils [as 别名]
# 或者: from lib.buffer_utils.BufferUtils import logical_to_index [as 别名]
    def draw(self, dt):

        self._current_time += dt
        
        # Spontaneous birth: Rare after startup
        if (len(self._dragons) < self.parameter('pop-limit').get()) and random.random() < self.parameter('birth-rate').get():
            strand = random.randint(0, BufferUtils.num_strands - 1)
            fixture = random.randint(0, BufferUtils.strand_num_fixtures(strand) - 1)
            address = BufferUtils.logical_to_index((strand, fixture, 0))
            if address not in [d.loc for d in self._dragons]:
                self._dragons.append(self.Dragon(address, 1, self._current_time))

        growth_rate = self.parameter('growth-rate').get()
        
        # Dragon life cycle
        for dragon in self._dragons:
            # Fade in
            if dragon.growing:
                p = (self._current_time - dragon.lifetime) / self.parameter('growth-time').get()
                if (p > 1):
                    p = 1.0
                color = self._growth_fader.get_color(p * self._fader_steps)
                if p >= 1.0:
                    dragon.growing = False
                    dragon.alive = True
                    dragon.lifetime = self._current_time

                self.setPixelHLS(dragon.loc, color)

            # Alive - can move or die
            if dragon.alive:

                dragon.growth += dt * growth_rate
                for times in range(int(dragon.growth)):
                    s, f, p = BufferUtils.index_to_logical(dragon.loc)
                    self.setPixelHLS(dragon.loc, (0, 0, 0))

                    if random.random() < dragon.growth:
                        dragon.growth -= 1
                    
                        # At a vertex: optionally spawn new dragons
                        if dragon.moving and (p == 0 or p == (self.scene().fixture(s, f).pixels - 1)):
                            neighbors = self.scene().get_pixel_neighbors(dragon.loc)
                            neighbors = [BufferUtils.index_to_logical(n) for n in neighbors]
                            random.shuffle(neighbors)

                            # Kill dragons that reach the end of a fixture
                            dragon.moving = False
                            if dragon in self._dragons:
                                self._dragons.remove(dragon)
                                
                            # Iterate over candidate pixels that aren't on the current fixture
                            num_children = 0
                            for candidate in [n for n in neighbors if n[1] != f]:
                                child_index = BufferUtils.logical_to_index(candidate)
                                if num_children == 0:
                                    # Spawn at least one new dragon to replace the old one.  This first one skips the growth.
                                    dir = 1 if candidate[2] == 0 else -1
                                    child = self.Dragon(child_index, dir, self._current_time)
                                    child.growing = False
                                    child.alive = True
                                    child.moving = False
                                    self._dragons.append(child)
                                    num_children += 1
                                elif (len(self._dragons) < self.parameter('pop-limit').get()):
                                    # Randomly spawn new dragons
                                    if random.random() < self.parameter('birth-rate').get():
                                        dir = 1 if candidate[2] == 0 else -1
                                        child = self.Dragon(child_index, dir, self._current_time)
                                        child.moving = False

                                        self._dragons.append(child)
                                        num_children += 1
                            break;
                        else:
                            # Move dragons along the fixture
                            self._tails.append((dragon.loc, self._current_time, self._tail_fader))
                            new_address = BufferUtils.logical_to_index((s, f, p + dragon.dir))
                            dragon.loc = new_address
                            dragon.moving = True
                            self.setPixelHLS(new_address, self._alive_color)

                    # Kill dragons that run into each other
                    if dragon in self._dragons:
                        colliding = [d for d in self._dragons if d != dragon and d.loc == dragon.loc]
                        if len(colliding) > 0:
                            #print "collision between", dragon, "and", colliding[0]
                            self._dragons.remove(dragon)
                            self._dragons.remove(colliding[0])
                            self._tails.append((dragon.loc, self._current_time, self._explode_fader))
                            neighbors = self.scene().get_pixel_neighbors(dragon.loc)
                            for neighbor in neighbors:
                                self._tails.append((neighbor, self._current_time, self._explode_fader))
                            break

        # Draw tails
        for loc, time, fader in self._tails:
            if (self._current_time - time) > self.parameter('tail-persist').get():
                if (loc, time, fader) in self._tails:
                    self._tails.remove((loc, time, fader))
#.........这里部分代码省略.........