public void resetFieldToFilter(FilterType type, IFilterComponent component)
{
string text = (component == null) ? String.Empty : ConvertWordListToText(component.getItems());
switch (type)
{
case FilterType.UserBlackList:
UserBlacklist = text;
break;
case FilterType.UserWhiteList:
UserWhitelist = text;
break;
case FilterType.WordBlackList:
WordBlacklist = text;
break;
case FilterType.WordWhiteList:
WordWhitelist = text;
break;
default:
break;
}
}
public CompositeFilter(IFilterComponent secondInput, CompositeOperator operation, decimal k1, decimal k2, decimal k3, decimal k4)
{
SecondInput = secondInput;
Operation = operation;
K1 = k1;
K2 = k2;
K3 = k3;
K4 = k4;
}
public FilterItem(FilterType filterType, IFilterComponent filterComponent)
{
if (filterComponent == null)
{
throw new ArgumentNullException("filterComponent");
}
FilterType = filterType;
FilterComponent = filterComponent;
}
public void Init()
{
_filter = new FilterComponent();
_pdf = new PdfComponent();
_pdf.Open(new FileInfo(@"C:\Users\Alexander\Desktop\AMM new.pdf"));
_chapters = _pdf.GetChapters;
_pdf = null;
}
public static JProperty CreateQueryComponent(this IFilterComponent comp)
{
var type = comp.GetType();
var props = type.GetProperties();
JObject filterGroup = new JObject();
JObject filters = new JObject();
foreach (var prop in props)
{
var value = prop.GetValue(comp);
if (value == null)
{
continue;
}
var attr = prop.CustomAttributes.OfType <QueryComponentAttribute>().FirstOrDefault();
if (attr == null || attr.Ignore)
{
continue;
}
var filter = new JObject();
if (prop.PropertyType == typeof(RangeFilter))
{
filter[attr.Name] = ParseRange((RangeFilter)value);
}
else if (prop.PropertyType.IsEnum)
{
filter[attr.Name] = ParseOption((Enum)value);
}
else
{
filter[attr.Name] = new JValue(value);
}
filters.Add(filter);
}
filterGroup["filters"] = filters;
return(new JProperty(type.GetCustomAttributes(false).OfType <QueryComponentAttribute>().First().Name, filterGroup));
}
internal static XElementBuilder BuildFilter(IFilterComponent component, CoordinatesConverter converter)
{
var firstAttempt = BuildFilterComponent(component, converter)
.Run(FilterChainState.Initial());
var firstAttemptItems = firstAttempt.Value.ToList();
List <XElement> filterChainList;
if (firstAttemptItems.Any() == true)
{
filterChainList = firstAttemptItems;
}
else
{
var filterComponent = Filters.Noop;
filterChainList = BuildFilterComponent(filterComponent, converter)
.Run(firstAttempt.State).Value.ToList();
}
return
(XElementBuilder.WithName("filter")
.Add(filterChainList));
}
public BlendFilter(IFilterComponent source2, BlendMode blendMode)
{
Source2 = source2;
BlendModeType = blendMode;
}
public DisplacementFilter(IFilterComponent displacementProvider, decimal scale)
{
DisplacementProvider = displacementProvider;
Scale = scale;
}
public FiltersAggregate Add(string name, IFilterComponent filter)
{
Components.Set(name, filter);
return(this);
}
public void Add(FilterType filterType, IFilterComponent filterComponent)
{
Items.Add(new FilterItem(filterType, filterComponent));
}
private static State <FilterChainState, (IEnumerable <XElement> FilterInputs, XElement MergeNode)> BuildInputAndMergeNode(IFilterComponent component, CoordinatesConverter converter) =>
public Collection(
ICompareComponent compare,
ICreationComponent creator,
IDelegationComponent delegation,
IFilterComponent filter,
IMapReduceComponent mapReduce,
IPartitionComponent partitioner,
ISetComponent set,
IZipComponent zip,
IUnZipComponent unzip
)
{
if (compare == null)
{
throw new ArgumentNullException("compare");
}
if (creator == null)
{
throw new ArgumentNullException("creator");
}
if (delegation == null)
{
throw new ArgumentNullException("delegation");
}
if (filter == null)
{
throw new ArgumentNullException("filter");
}
if (mapReduce == null)
{
throw new ArgumentNullException("mapReduce");
}
if (partitioner == null)
{
throw new ArgumentNullException("partitioner");
}
if (set == null)
{
throw new ArgumentNullException("set");
}
if (zip == null)
{
throw new ArgumentNullException("zip");
}
if (unzip == null)
{
throw new ArgumentNullException("unzip");
}
_compare = compare;
_creator = creator;
_delegation = delegation;
_filter = filter;
_mapReduce = mapReduce;
_partitioner = partitioner;
_set = set;
_zip = zip;
_unzip = unzip;
}
public static IFilterComponent Blend(IFilterComponent secondInput, BlendMode blendMode) => new BlendFilter(secondInput, blendMode);
public static IFilterComponent Multiply(IFilterComponent filterComponent) => new CompositeFilter(filterComponent, CompositeOperator.Arithmetic, 1, 0, 0, 0);
public FilterComponentNotSupportedException(IFilterComponent component) : base($"filter component of type {component.GetType()} is not supported.")
{
}
private static State <FilterChainState, IEnumerable <XElement> > BuildTwoInputFilter(XElementBuilder elementCore, IFilterComponent input2, CoordinatesConverter converter) =>
from startingState in State.Get <FilterChainState>()
from input2ProviderElements in BuildFilterComponent(input2, converter)
from input2Attribute in Input2AttributeBuilder
from postDisplacementState in State.Get <FilterChainState>()
from resetStartingState in FilterChainState.SetInputId(startingState.NextInputId)
let displacementBuilder = elementCore
.Add(input2Attribute)
from finalElement in BuildIOFilter(displacementBuilder)
select input2ProviderElements.Concat(new[] { finalElement.Build() });
public FilterProperty(IFilterComponent filterComponent)
{
FilterComponent = filterComponent;
}
private static State <FilterChainState, IEnumerable <XElement> > BuildFilterComponent(
IFilterComponent component,
CoordinatesConverter converter)
{
if (component is ColorMatrix colorMatrix)
{
return(BuildColorMatrix(colorMatrix).Select(x => new[] { x }.AsEnumerable()));
}
if (component is GaussianBlurFilter gaussFilter)
{
return(BuildGaussianBlur(gaussFilter, converter)
.Select(x => new[] { x }.AsEnumerable()));
}
if (component is DropShadowFilter dropShadowFilter)
{
return(BuildDropShadowFilter(dropShadowFilter, converter).Select(x => new[] { x }.AsEnumerable()));
}
if (component is FilterChain chain)
{
return(BuildFilterChain(chain, converter));
}
if (component is DisplacementFilter displacementFilter)
{
return(BuildDisplacementFilter(displacementFilter, converter));
}
if (component is TurbulenceGenerator turbulenceGenerator)
{
return(BuildTurbulenceGenerator(turbulenceGenerator).Select(x => new[] { x }.AsEnumerable()));
}
if (component is FloodGenerator floodGenerator)
{
return(BuildFloodGenerator(floodGenerator.Color).Select(x => new[] { x.Build() }.AsEnumerable()));
}
if (component is BlendFilter blendFilter)
{
return(BuildBlendFilter(blendFilter, converter));
}
if (component is FilterSource filterSource)
{
return
(from state in FilterChainState.SetInputToSource(filterSource.SourceType)
select Enumerable.Empty <XElement>());
}
if (component is MergeFilter mergeFilter)
{
return(BuildMergeFilter(mergeFilter, converter));
}
if (component is Morphology morphology)
{
return(BuildMorphologyFilter(morphology, converter));
}
if (component is OffsetFilter offsetFilter)
{
return(BuildOffsetFilter(offsetFilter, converter));
}
if (component is CompositeFilter compositeFilter)
{
return(BuildCompositeFilter(compositeFilter, converter));
}
if (component is DiffuseLightingGenerator diffuseLightingGenerator)
{
return(BuildDiffuseLightingGenerator(diffuseLightingGenerator, converter));
}
if (component is SpecularLightingGenerator specularLightingGenerator)
{
return(BuildSpecularLightingGenerator(specularLightingGenerator, converter));
}
throw new FilterComponentNotSupportedException(component);
}
