apply filter into special area

F.partial({x,y,width,height}, filter, filter, filter )
F.partial({x,y,width,height}, 'filter' )

@param {{x, y, width, height}} area
@param {*} filters
514961
function partial(area) {
    var allFilter = null;

    for (var _len2 = arguments.length, filters = Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
        filters[_key2 - 1] = arguments[_key2];
    }

    if (filters.length == 1 && typeof filters[0] === 'string') {
        allFilter = filter$1(filters[0]);
    } else {
        allFilter = merge$1(filters);
    }

    return function (bitmap, done) {
        var opt = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};

        allFilter(getBitmap(bitmap, area), function (newBitmap) {
            done(putBitmap(bitmap, newBitmap, area));
        }, opt);
    };
}
378662
function (newFilters, oldFilters) {
        var self = this;

        if (!oldFilters) {
            oldFilters = this._filters;
        } else if (!isArray(oldFilters)) {
            oldFilters = [oldFilters];
        }

        if (!newFilters) {
            newFilters = [];
        } else if (!isArray(newFilters)) {
            newFilters = [newFilters];
        }

        oldFilters.forEach(function (filter) {
            self._removeFilter(filter);
        });

        newFilters.forEach(function (filter) {
            self._addFilter(filter);
        });

        this._runFilters();
    }
1054675
function(coords) {
        var i, j, area = 0;
        for (i = 0; i < coords.length; i++) {
            j = (i + 1) % coords.length;
            area += coords[i][0] * coords[j][1];
            area -= coords[j][0] * coords[i][1];
        }
        return (area < 0);
    }
338967
function (filters, tpl) {
      for (var i = 0; i < filters.length; ++i) {
        tpl = filters[i](tpl)
      }
      return tpl
    }
1168366
private void setAreaPointPredicates_() {
        m_predicates_cluster = Predicates.AreaPointPredicates;

        m_max_dim[MatrixPredicate.InteriorInterior] = 0;
        m_max_dim[MatrixPredicate.InteriorBoundary] = -1;
        m_max_dim[MatrixPredicate.InteriorExterior] = 2;
        m_max_dim[MatrixPredicate.BoundaryInterior] = 0;
        m_max_dim[MatrixPredicate.BoundaryBoundary] = -1;
        m_max_dim[MatrixPredicate.BoundaryExterior] = 1;
        m_max_dim[MatrixPredicate.ExteriorInterior] = 0;
        m_max_dim[MatrixPredicate.ExteriorBoundary] = -1;
        m_max_dim[MatrixPredicate.ExteriorExterior] = 2;

        // set predicates that are always true/false
        if (m_perform_predicates[MatrixPredicate.InteriorBoundary])
        {
            m_matrix[MatrixPredicate.InteriorBoundary] = -1; // Always false
            m_perform_predicates[MatrixPredicate.InteriorBoundary] = false;
            m_predicate_count--;
        }

        if (m_perform_predicates[MatrixPredicate.BoundaryBoundary])
        {
            m_matrix[MatrixPredicate.BoundaryBoundary] = -1; // Always false
            m_perform_predicates[MatrixPredicate.BoundaryBoundary] = false;
            m_predicate_count--;
        }

        if (m_perform_predicates[MatrixPredicate.ExteriorBoundary])
        {
            m_matrix[MatrixPredicate.ExteriorBoundary] = -1; // Always false
            m_perform_predicates[MatrixPredicate.ExteriorBoundary] = false;
            m_predicate_count--;
        }

        if (m_perform_predicates[MatrixPredicate.ExteriorExterior])
        {
            m_matrix[MatrixPredicate.ExteriorExterior] = 2; // Always true
            m_perform_predicates[MatrixPredicate.ExteriorExterior] = false;
            m_predicate_count--;
        }
	}
250849
function area(p, q, r) {
       return (q.y - p.y) * (r.x - q.x) - (q.x - p.x) * (r.y - q.y);
   }
1299885
function forEachArea( page, f ) {
   const { areas } = page.definition;
   for( const name in areas ) {
      if( areas.hasOwnProperty( name ) ) {
         f( areas[ name ], name );
      }
   }
}
262531
def apply_filter(x, filter=None, axis=0):
    """"""
    x = _as_array(x)
    if x.shape[axis] == 0:
        return x
    b, a = filter
    return signal.filtfilt(b, a, x, axis=axis)
1257715
def partial(f, x, i):
    
    result = f(*[AdFloat(x_j, j == i) for j, x_j in enumerate(x)])
    return result.dx
668769
def within(self, lat, lon, radius):
		''''''
		return self.filter(filter_helpers.within_(lat, lon, radius))
1326441
def datagrid_filter(filter_or_attribute, options = {}, &block)
      filter = datagrid_get_filter(filter_or_attribute)
      options = add_html_classes(options, filter.name, datagrid_filter_html_class(filter))
      # Prevent partials option from appearing in HTML attributes
      options.delete(:partials) # Legacy option
      self.send(filter.form_builder_helper_name, filter, options, &block)
    end
520089
function renderLayout( pageElement, areaHelper, layoutInfo ) {
         addClass( pageElement, layoutInfo.className );
         pageElement.innerHTML = layoutInfo.html;

         const areas = findWidgetAreas( pageElement );
         const deregisterFuncs = Object.keys( areas )
            .map( areaName => areaHelper.register( areaName, areas[ areaName ] ) );

         DEFAULT_AREAS.forEach( area => {
            if( areaHelper.exists( area.name ) ) {
               return;
            }

            const node = document.createElement( 'div' );
            if( area.hidden ) {
               node.style.display = 'none';
            }
            deregisterFuncs.push( areaHelper.register( area.name, node, area.name ) );
            pageElement.appendChild( node );
         } );

         return () => {
            deregisterFuncs.forEach( func => func() );
            removeClass( pageElement, layoutInfo.className );
         };
      }
280985
function wrap(fn, wrapper) {
        if (!wrapper)
            wrapper = function(f){ f.apply(this, slice.call(arguments, 1)) }

        return partial(wrapper, fn)
    }
493557
function(filter) {
        if (!this.isActive())
            throw "Trying to set filter of texture that isn't active";
        var gl = this.gl;
        gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, filter);
        gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, filter);
    }
758012
private void addAreas() {
        if (areas != null) {
            removeAllViews();
            scrollView = null;
            topDivider = null;
            bottomDivider = null;
            Area previousArea = null;
            boolean canAddTopDivider = false;

            for (Map.Entry<Area, View> entry : areas.entrySet()) {
                Area area = entry.getKey();
                View view = entry.getValue();

                if (scrollableArea.isScrollable(area)) {
                    if (topDivider == null && canAddTopDivider &&
                            !scrollableArea.isScrollable(previousArea)) {
                        topDivider = addDivider();
                    }

                    inflateScrollView(scrollableArea);
                    ViewGroup scrollContainer =
                            scrollView.getChildCount() > 0 ? (ViewGroup) scrollView.getChildAt(0) :
                                    scrollView;
                    view.getViewTreeObserver()
                            .addOnGlobalLayoutListener(createScrollViewChildLayoutListener());
                    scrollContainer.addView(view);
                } else {
                    if (bottomDivider == null && previousArea != null &&
                            scrollableArea.getBottomScrollableArea() != null &&
                            scrollableArea.getBottomScrollableArea().getIndex() < area.getIndex() &&
                            view.getVisibility() == View.VISIBLE && area != Area.BUTTON_BAR) {
                        bottomDivider = addDivider();
                    }

                    addView(view);
                }

                canAddTopDivider |= area != Area.HEADER && view.getVisibility() == View.VISIBLE;
                previousArea = area;
            }

            adaptAreaPadding();
            findListView();
        }
    }
589608
private void analyzeAreaSeparators(AreaImpl area)
    {
        boolean isep = area.isExplicitlySeparated() || area.isBackgroundSeparated();
        if (isep || area.separatedUp())
            bsep.add(new Separator(Separator.BOXH,
                                   area.getX1(), area.getY1(), area.getX2(), area.getY1() + ART_SEP_WIDTH - 1));
        if (isep || area.separatedDown())
            bsep.add(new Separator(Separator.BOXH,
                                   area.getX1(), area.getY2() - ART_SEP_WIDTH + 1, area.getX2(), area.getY2()));
        if (isep || area.separatedLeft())
            bsep.add(new Separator(Separator.BOXV,
                                   area.getX1(), area.getY1(), area.getX1() + ART_SEP_WIDTH - 1, area.getY2()));
        if (isep || area.separatedRight())
            bsep.add(new Separator(Separator.BOXV,
                                   area.getX2() - ART_SEP_WIDTH + 1, area.getY1(), area.getX2(), area.getY2()));
    }
592479
public void setAreas(Section... AREAS_ARRAY) {
        areas.clear();
        for (Section area : AREAS_ARRAY) {
            areas.add(new Section(area.getStart(), area.getStop(), area.getColor()));
        }
        validate();
        fireStateChanged();
    }