generate_spatial()

void MayaFlux::Buffers::LogicProcessor::generate_spatial ( size_t  num_samples, const std::vector< double > &  input_data  )

private

Definition at line 154 of file LogicProcessor.cpp.

{
    if (num_samples == 0) {
        return;
    }
 
    const size_t available = input_data.size();
    const size_t width = 2 * m_radius + 1;
    const auto count = static_cast<std::ptrdiff_t>(num_samples);
 
    m_cells.assign(num_samples, 0);
    m_next_cells.assign(num_samples, 0);
    m_slots.assign(width, 0.0);
 
    for (size_t i = 0; i < num_samples; ++i) {
        uint8_t cell = (i < available && input_data[i] > 0.0) ? 1 : 0;
        if (m_memory && i < m_previous_cells.size()) {
            cell ^= m_previous_cells[i];
        }
        m_cells[i] = cell;
    }
 
    for (size_t generation = 0; generation < m_generations; ++generation) {
        for (std::ptrdiff_t i = 0; i < count; ++i) {
            for (size_t k = 0; k < width; ++k) {
                std::ptrdiff_t at = i + static_cast<std::ptrdiff_t>(m_radius) - static_cast<std::ptrdiff_t>(k);
                double cell = 0.0;
                if (at >= 0 && at < count) {
                    cell = m_cells[static_cast<size_t>(at)];
                } else if (m_wrap) {
                    at = ((at % count) + count) % count;
                    cell = m_cells[static_cast<size_t>(at)];
                }
                m_slots[k] = cell;
            }
            m_next_cells[static_cast<size_t>(i)] = m_logic->process_multi_input(m_slots) > 0.5 ? 1 : 0;
        }
        m_cells.swap(m_next_cells);
    }
 
    for (size_t i = 0; i < num_samples; ++i) {
        m_logic_data[i] = m_cells[i];
    }
    if (m_memory) {
        m_previous_cells = m_cells;
    }
}

References available, count, m_cells, m_generations, m_logic, m_logic_data, m_memory, m_next_cells, m_previous_cells, m_radius, m_slots, m_wrap, and width.

Referenced by generate().

Here is the caller graph for this function: