:topic: Filter and Pipeline Overview

.. index::
   triple: DREAM3D-NX; Concepts; Filters
   triple: DREAM3D-NX; Concepts; Pipline


Filters & Pipelines
#######################

To process data through DREAM3D-NX, the user will need to insert one or more
**Filters** into a **Pipeline**, and then execute or "Run" the pipeline.

Filters
========

A **Filter** can be considered an operation that is performed on the DataStructure. The operation
can be one of basic data array modification, creation of new data arrays, deletion
of data arrays, reading data from disk, writing data to disk or any other operation 
that a developer can program. Filters typically require input from the user in the form of **Filter Parameters**.
Each filter parameter allows the user to set a specific input value that the filter will use to properly
execute itself. There are many kinds of filter parameters available through out DREAM3D-NX ranging
from simple string and numeric values to more complex parameters such as reading data from a CSV
data file.

For more information about how to find **Filters** in the interface, see the
`Filter List View <../../03_User%20Interface/030_FilterListView/index.html>`__
section.

Pipeline
=========

A **Pipeline** is a collection of filters that are executed in the order in which 
they are inserted into the pipeline. Pipelines execute in a linear order and do
not have any ability to loop or branch (yet). Pipelines are saved as standard JSON fomratted
text files. More
information on creating **Pipelines** can be found in the `Creating A
Pipeline <../../03_User%20Interface/130_CreatingAPipeline/index.html>`__
section.

A Visual Programming Paradigm
=============================

If one considers each filter to act like a 'function' from a programming language, then the
filter parameters are the arguments to that function. By allowing the user to
hook together multiple filters into processing 'pipeline' the real power of DREAM3D-NX
can truly be realized. By using DREAM3D-NX user interface non-programmers can easily
"program" a larger data processing algorithm that includes many smaller algorithms (filters).
