int console_filter_selection(ContextPtr env, char *cmd) {
if(!cmd) return 0;
LinkList<Filter> &list = env->getFilters();
LinkList<Filter>::iterator it = std::find_if(list.begin(), list.end(), [&](FilterPtr filter) {
return filter->getName() == cmd;
});
if(it == list.end()) {
::error("filter not found: %s", cmd);
return 0;
}
FilterPtr filt = *it;
ViewPortPtr screen = getSelectedScreen();
if(!screen) {
::error("no screen currently selected");
return 0;
}
LayerPtr lay = getSelectedLayer();
if(!lay) {
::error("no layer selected for effect %s", filt->getName().c_str());
return 0;
}
if(!filt->new_instance()->apply(lay)) {
::error("error applying filter %s on layer %s", filt->getName().c_str(), lay->getName().c_str());
return 0;
}
// select automatically the new filter
// lay->filters.sel(0);
// ff->sel(true);
return 1;
}
FilterPtr FilterFactory::createFilter(const String &name, DepthCamera::FrameType type)
{
auto x = _supportedFilters.find(name);
if(x == _supportedFilters.end())
{
logger(LOG_ERROR) << "FilterFactory: Could not find filter '" << name << "'" << std::endl;
return nullptr;
}
if(!x->second.supports(type))
{
logger(LOG_ERROR) << "FilterFactory: Filter '" << name << "' does not support frame type '" << type << "'" << std::endl;
return nullptr;
}
if(!x->second._createFilter)
{
logger(LOG_ERROR) << "FilterFactory: Don't know how to create filter '" << name << "'. Report to vendor of FilterFactory '" << _name << "'" << std::endl;
return nullptr;
}
FilterPtr p = x->second._createFilter();
if(p) p->setNameScope(_name);
return p;
}
void FilterGroup::append(FilterPtr filter)
{
mFilters.push_back(filter);
QString uid = QString("%1_%2").arg(filter->getType()).arg(mFilters.size());
XmlOptionFile node = mOptions.descend(uid);
filter->initialize(node.getElement(), uid);
}
// Test that sequence limiting works
void test16(const DestinationPtr &sink1) {
banner("test16 - sequence limiting");
FilterPtr limited = SequenceFilter::instance(10, 2, 5); // every other message beginning with #10, five total
limited->addDestination(sink1);
Stream merr = Stream("test16", INFO, limited);
for (size_t i=0; i<100; ++i) {
merr <<"i=" <<i <<"\n";
}
}
FilterPtr FilterEngine::GetWhitelistingFilter(const std::string& url,
ContentType contentType, const std::string& documentUrl) const
{
FilterPtr match = Matches(url, contentType, documentUrl);
if (match && match->GetType() == Filter::TYPE_EXCEPTION)
{
return match;
}
return FilterPtr();
}
// Test that rate limiting works
void test15(const DestinationPtr &sink1) {
banner("test15 - rate limiting");
FilterPtr limited = TimeFilter::instance(0.5);
limited->addDestination(sink1);
Stream merr = Stream("test15", INFO, limited);
for (size_t i=0; i<5000000; ++i) {
merr <<"i=" <<i <<"\n";
}
}
HttpsClientTransport::HttpsClientTransport(const HttpsEndpoint & httpsEndpoint) :
TcpClientTransport(httpsEndpoint.getIp(), httpsEndpoint.getPort())
{
std::vector<FilterPtr> wireFilters;
// HTTP framing.
wireFilters.push_back( FilterPtr( new HttpFrameFilter(
getRemoteAddr().getIp(),
getRemoteAddr().getPort())));
// SSL.
ClientStub * pClientStub = getTlsClientStubPtr();
RCF_ASSERT(pClientStub);
FilterPtr sslFilterPtr;
#if RCF_FEATURE_SSPI==1 && RCF_FEATURE_OPENSSL==1
if (pClientStub->getSslImplementation() == Si_Schannel)
{
sslFilterPtr.reset( new SchannelFilter(pClientStub) );
}
else
{
RCF_ASSERT(pClientStub->getSslImplementation() == Si_OpenSsl);
sslFilterPtr.reset( new OpenSslEncryptionFilter(pClientStub) );
}
#elif RCF_FEATURE_SSPI==1
sslFilterPtr.reset( new SchannelFilter(pClientStub) );
#elif RCF_FEATURE_OPENSSL==1
sslFilterPtr.reset( new OpenSslEncryptionFilter(pClientStub) );
#endif
if (!sslFilterPtr)
{
RCF_THROW( Exception(_RcfError_SslNotSupported()) );
}
wireFilters.push_back(sslFilterPtr);
// HTTP CONNECT filter for passing through a proxy.
wireFilters.push_back( FilterPtr( new HttpConnectFilter(
getRemoteAddr().getIp(),
getRemoteAddr().getPort())));
setWireFilters(wireFilters);
}
/** Set all options with the named valueName to the value,
* given that they are of the correct type.
*
* Supported types: bool, double, QString, QColor
*/
void Pipeline::setOption(QString valueName, QVariant value)
{
for (unsigned i=0; i<mFilters->size(); ++i)
{
FilterPtr filter = mFilters->get(i);
std::vector<PropertyPtr> options = filter->getOptions();
for (unsigned j=0; j<options.size(); ++j)
{
if (options[j]->getDisplayName()==valueName)
this->setOption(options[j], value);
}
}
}
int console_filter_completion(ContextPtr env, char *cmd) {
if(!cmd) return 0;
// Find completions
FilterPtr exactFilter;
LinkList<Filter> retList;
LinkList<Filter> &list = env->getFilters();
std::string cmdString(cmd);
std::transform(cmdString.begin(), cmdString.end(), cmdString.begin(), ::tolower);
std::copy_if(list.begin(), list.end(), retList.begin(), [&] (FilterPtr filter) {
std::string name = filter->getName();
std::transform(name.begin(), name.end(), name.begin(), ::tolower);
if(name == cmdString) {
exactFilter = filter;
}
return name.compare(cmdString) == 0;
});
if(retList.empty()) return 0;
if(exactFilter != NULL) {
::notice("%s :: %s", exactFilter->getName().c_str(), exactFilter->getDescription().c_str());
snprintf(cmd, MAX_CMDLINE, "%s", exactFilter->getName().c_str());
return 1;
}
if(cmdString.empty()) {
notice("List available filters");
} else {
notice("List available filters with \"%s\"", cmd);
}
int c = 0;
char tmp[256];
std::for_each(retList.begin(), retList.end(), [&] (FilterPtr f) {
if(c % 4 == 0) {
if(c != 0) {
::act("%s", tmp);
}
tmp[0] = '\0';
}
strncat(tmp, "\t", sizeof(tmp) - 1);
strncat(tmp, f->getName().c_str(), sizeof(tmp) - 1);
++c;
});
return c;
}
void ClientStub::createFilterSequence(
std::vector<FilterPtr> & filters)
{
filters.clear();
// Setup compression if configured.
if (mEnableCompression)
{
#if RCF_FEATURE_ZLIB==1
FilterPtr filterPtr( new ZlibStatefulCompressionFilter() );
filters.push_back(filterPtr);
#else
RCF_ASSERT(0);
#endif
}
FilterPtr filterPtr;
if (mTransportProtocol != Tp_Clear && mTransportProtocol != Tp_Unspecified)
{
switch (mTransportProtocol)
{
#if RCF_FEATURE_SSPI==1
case Tp_Ntlm: filterPtr.reset( new NtlmFilter(this) ); break;
case Tp_Kerberos: filterPtr.reset( new KerberosFilter(this) ); break;
case Tp_Negotiate: filterPtr.reset( new NegotiateFilter(this) ); break;
#endif
#if RCF_FEATURE_OPENSSL==1 && RCF_FEATURE_SSPI==1
case Tp_Ssl: if (mSslImplementation == Si_Schannel)
{
filterPtr.reset( new SchannelFilter(this) );
}
else
{
RCF_ASSERT(mSslImplementation == Si_OpenSsl);
filterPtr.reset( new OpenSslEncryptionFilter(this) );
}
break;
#elif RCF_FEATURE_OPENSSL==1
case Tp_Ssl: filterPtr.reset( new OpenSslEncryptionFilter(this) ); break;
#elif RCF_FEATURE_SSPI==1
case Tp_Ssl: filterPtr.reset( new SchannelFilter(this) ); break;
#else
// Single case just to keep the compiler warnings quiet.
case Tp_Ssl:
#endif
default:
RCF_THROW( Exception( _RcfError_TransportProtocolNotSupported( getTransportProtocolName(mTransportProtocol)) ) );
}
}
if (filterPtr)
{
filters.push_back(filterPtr);
}
}
void ClientStub::requestTransportFilters(FilterPtr filterPtr)
{
std::vector<FilterPtr> filters;
if (filterPtr.get())
{
filters.push_back(filterPtr);
}
requestTransportFilters(filters);
}
void ClientStub::requestTransportFiltersAsync(
FilterPtr filterPtr,
boost::function0<void> onCompletion)
{
std::vector<FilterPtr> filters;
if (filterPtr.get())
{
filters.push_back(filterPtr);
}
requestTransportFiltersAsync(filters, onCompletion);
}
// Demonstrate rate limiting per importance level
void test15b(const DestinationPtr &sink1) {
banner("test15b - per importance rate limiting");
Facility log("test15b", sink1);
for (size_t i=DEBUG; i<=FATAL; ++i) {
Importance imp = (Importance)i;
FilterPtr limiter = TimeFilter::instance(1.0);
limiter->addDestination(log[imp].destination());
log[imp].destination(limiter);
}
for (size_t i=0; i<300000; ++i) {
log[DEBUG] <<"i=" <<i <<"\tdebugging message\n";
log[TRACE] <<"i=" <<i <<"\ttracing message\n";
log[WHERE] <<"i=" <<i <<"\tmajor execution point\n";
log[INFO] <<"i=" <<i <<"\tinformational message\n";
log[WARN] <<"i=" <<i <<"\twarning message\n";
log[ERROR] <<"i=" <<i <<"\terror message\n";
log[FATAL] <<"i=" <<i <<"\tfatal error message\n";
}
}
static void checkDocIdSetCacheable(IndexReaderPtr reader, FilterPtr filter, bool shouldCacheable)
{
CachingWrapperFilterPtr cacher = newLucene<CachingWrapperFilter>(filter);
DocIdSetPtr originalSet = filter->getDocIdSet(reader);
DocIdSetPtr cachedSet = cacher->getDocIdSet(reader);
BOOST_CHECK(cachedSet->isCacheable());
BOOST_CHECK_EQUAL(shouldCacheable, originalSet->isCacheable());
if (originalSet->isCacheable())
BOOST_CHECK(MiscUtils::equalTypes(originalSet, cachedSet));
else
BOOST_CHECK(MiscUtils::typeOf<OpenBitSetDISI>(cachedSet));
}
void AppenderSkeleton::doAppend(const spi::LoggingEventPtr& event, Pool& pool1)
{
synchronized sync(mutex);
if(closed)
{
LogLog::error(((LogString) LOG4CXX_STR("Attempted to append to closed appender named ["))
+ name + LOG4CXX_STR("]."));
return;
}
if(!isAsSevereAsThreshold(event->getLevel()))
{
return;
}
FilterPtr f = headFilter;
while(f != 0)
{
switch(f->decide(event))
{
case Filter::DENY:
return;
case Filter::ACCEPT:
f = 0;
break;
case Filter::NEUTRAL:
f = f->getNext();
}
}
append(event, pool1);
}
void Pipeline::initialize(FilterGroupPtr filters)
{
mFilters = filters;
for (unsigned i=0; i<mFilters->size(); ++i)
{
FilterPtr filter = mFilters->get(i);
filter->getInputTypes();
filter->getOutputTypes();
filter->getOptions();
}
this->getNodes();
for (unsigned i=0; i<mFilters->size(); ++i)
{
FilterPtr current = mFilters->get(i);
mTimedAlgorithm[current->getUid()].reset(new FilterTimedAlgorithm(current));
}
}
IECore::ConstFloatVectorDataPtr Reformat::computeChannelData( const std::string &channelName, const Imath::V2i &tileOrigin, const Gaffer::Context *context, const ImagePlug *parent ) const
{
// Allocate the new tile
FloatVectorDataPtr outDataPtr = new FloatVectorData;
std::vector<float> &out = outDataPtr->writable();
out.resize( ImagePlug::tileSize() * ImagePlug::tileSize() );
// Create some useful variables...
Imath::V2f scaleFactor( scale() );
Imath::V2d inFormatOffset( inPlug()->formatPlug()->getValue().getDisplayWindow().min );
Imath::V2d outFormatOffset( formatPlug()->getValue().getDisplayWindow().min );
Imath::Box2i outTile( tileOrigin, Imath::V2i( tileOrigin.x + ImagePlug::tileSize() - 1, tileOrigin.y + ImagePlug::tileSize() - 1 ) );
Imath::Box2f inTile(
Imath::V2f(
double( outTile.min.x - outFormatOffset.x ) / scaleFactor.x + inFormatOffset.x,
double( outTile.min.y - outFormatOffset.y ) / scaleFactor.y + inFormatOffset.y
),
Imath::V2f(
double( outTile.max.x - outFormatOffset.x + 1. ) / scaleFactor.x + inFormatOffset.x - 1.,
double( outTile.max.y - outFormatOffset.y + 1. ) / scaleFactor.y + inFormatOffset.y - 1.
)
);
// Create our filter.
FilterPtr f = Filter::create( filterPlug()->getValue(), 1.f / scaleFactor.y );
// If we are filtering with a box filter then just don't bother filtering
// at all and just integer sample instead...
if ( static_cast<GafferImage::TypeId>( f->typeId() ) == GafferImage::BoxFilterTypeId )
{
Imath::Box2i sampleBox(
Imath::V2i( IECore::fastFloatFloor( inTile.min.x ), IECore::fastFloatCeil( inTile.min.y ) ),
Imath::V2i( IECore::fastFloatFloor( inTile.max.x ), IECore::fastFloatCeil( inTile.max.y ) )
);
Sampler sampler( inPlug(), channelName, sampleBox, f, Sampler::Clamp );
for ( int y = outTile.min.y, ty = 0; y <= outTile.max.y; ++y, ++ty )
{
for ( int x = outTile.min.x, tx = 0; x <= outTile.max.x; ++x, ++tx )
{
float value = sampler.sample( float( ( x + .5f - outFormatOffset.x ) / scaleFactor.x + inFormatOffset.x ), float( ( y + .5f - outFormatOffset.y ) / scaleFactor.y + inFormatOffset.y ) );
out[ tx + ImagePlug::tileSize() * ty ] = value;
}
}
return outDataPtr;
}
// Get the dimensions of our filter and create a box that we can use to define the bounds of our input.
int fHeight = f->width();
int sampleMinY = f->tap( inTile.min.y );
int sampleMaxY = f->tap( inTile.max.y );
f->setScale( 1.f / scaleFactor.x );
int sampleMinX = f->tap( inTile.min.x );
int sampleMaxX = f->tap( inTile.max.x );
int fWidth = f->width();
Imath::Box2i sampleBox(
Imath::V2i( sampleMinX, sampleMinY ),
Imath::V2i( sampleMaxX + fWidth, sampleMaxY + fHeight )
);
int sampleBoxWidth = sampleBox.size().x + 1;
int sampleBoxHeight = sampleBox.size().y + 1;
// Create a temporary buffer that we can write the result of the first pass to.
// We extend the buffer vertically as we will need additional information in the
// vertical squash (the second pass) to properly convolve the filter.
float buffer[ ImagePlug::tileSize() * sampleBoxHeight ];
// Create several buffers for each pixel in the output row (or column depending on the pass)
// into which we can place the indices for the pixels that are contribute to it's result and
// their weight.
// A buffer that holds a list of pixel contributions and their weights for every pixel in the output buffer.
// As it gets reused for both passes we make it large enough to hold both so that we don't have to resize it later.
std::vector<Contribution> contribution( ImagePlug::tileSize() * ( sampleBoxHeight > sampleBoxWidth ? sampleBoxHeight : sampleBoxWidth ) );
// The total number of pixels that contribute towards each pixel in th resulting image.
std::vector<int> coverageTotal( ImagePlug::tileSize() );
// The total weighted sum of contribution that each pixel in the output gets.
// This value is used to normalize the result.
std::vector<float> weightedSum( ImagePlug::tileSize() );
// Horizontal Pass
// Here we build a row buffer of contributing pixels and their weights for every pixel in the row.
int contributionIdx = 0;
for ( int i = 0; i < ImagePlug::tileSize(); ++i, contributionIdx += fWidth )
{
float center = ( outTile.min.x + i + 0.5 - outFormatOffset.x ) / scaleFactor.x + inFormatOffset.x;
int tap = f->tap( center );
int n = 0;
weightedSum[i] = 0.;
for ( int j = tap; j < tap+fWidth; ++j )
{
float weight = f->weight( center, j );
if ( weight == 0 )
{
continue;
}
contribution[contributionIdx+n].pixel = j;
weightedSum[i] += contribution[contributionIdx+n].weight = weight;
n++;
}
coverageTotal[i] = n;
}
// Now that we know the contribution of each pixel from the others on the row, compute the
// horizontally scaled buffer which we will use as input in the vertical scale pass.
Sampler sampler( inPlug(), channelName, sampleBox, f, Sampler::Clamp );
for ( int k = 0; k < sampleBoxHeight; ++k )
{
for ( int i = 0, contributionIdx = 0; i < ImagePlug::tileSize(); ++i, contributionIdx += fWidth )
{
float intensity = 0;
for ( int j = 0; j < coverageTotal[i]; ++j )
{
Contribution &contributor( contribution[ contributionIdx+j ] );
if ( contributor.weight == 0. )
{
continue;
}
float value = sampler.sample( contributor.pixel, k + sampleBox.min.y );
intensity += value * contributor.weight;
}
buffer[i + ImagePlug::tileSize() * k] = intensity / weightedSum[i];
}
}
// Vertical Pass
// Build the column buffer of contributing pixels and their weights for each pixel in the column.
f->setScale( 1.f / scaleFactor.y );
for ( int i = 0, contributionIdx = 0; i < ImagePlug::tileSize(); ++i, contributionIdx += fHeight )
{
float center = ( outTile.min.y - outFormatOffset.y + i + 0.5 ) / scaleFactor.y - sampleBox.min.y + inFormatOffset.y;
int tap = f->tap( center );
int n = 0;
weightedSum[i] = 0.;
for ( int j = tap; j < tap+fHeight; ++j )
{
float weight = f->weight( center, j );
if ( weight == 0 )
{
continue;
}
contribution[contributionIdx+n].pixel = j;
weightedSum[i] += contribution[contributionIdx+n].weight = weight;
n++;
}
coverageTotal[i] = n;
}
// Use the column buffer of pixel contributions to scale the temporary buffer vertically.
// Write the result into the output buffer.
for ( int k = 0; k < ImagePlug::tileSize(); ++k )
{
for ( int i = 0, contributionIdx = 0; i < ImagePlug::tileSize(); ++i, contributionIdx += fHeight )
{
float intensity = 0;
for ( int j = 0; j < coverageTotal[i]; ++j )
{
Contribution &contributor( contribution[ contributionIdx+j ] );
if ( contributor.weight == 0. )
{
continue;
}
intensity += buffer[ k + ImagePlug::tileSize() * contributor.pixel ] * contributor.weight;
}
out[k + ImagePlug::tileSize() * i] = intensity / weightedSum[i];
}
}
return outDataPtr;
}
// remotely accessible
boost::int32_t FilterService::RequestTransportFilters(const std::vector<boost::int32_t> &filterIds)
{
RCF_LOG_3()(filterIds) << "FilterService::RequestTransportFilters() - entry";
RcfSession & session = getCurrentRcfSession();
RcfServer & server = session.getRcfServer();
boost::shared_ptr< std::vector<FilterPtr> > filters(
new std::vector<FilterPtr>());
ReadLock readLock(mFilterFactoryMapMutex);
for (unsigned int i=0; i<filterIds.size(); ++i)
{
int filterId = filterIds[i];
if (filterId == RcfFilter_SspiSchannel || filterId == RcfFilter_OpenSsl)
{
if (server.getSslImplementation() == RCF::Si_Schannel)
{
filterId = RcfFilter_SspiSchannel;
}
else
{
filterId = RcfFilter_OpenSsl;
}
}
if (mFilterFactoryMap.find(filterId) == mFilterFactoryMap.end())
{
RCF_LOG_3()(filterId) << "FilterService::RequestTransportFilters() - filter not supported.";
return RcfError_UnknownFilter;
}
FilterFactoryPtr filterFactoryPtr = mFilterFactoryMap[filterId];
FilterPtr filterPtr( filterFactoryPtr->createFilter(server) );
filters->push_back(filterPtr);
}
// Determine which protocol, if any, the filter sequence represents.
session.mEnableCompression = false;
FilterPtr filterPtr;
if (filters->size() > 0)
{
if ( (*filters)[0]->getFilterId() == RcfFilter_ZlibCompressionStateful )
{
session.mEnableCompression = true;
if (filters->size() > 1)
{
filterPtr = (*filters)[1];
}
}
else
{
if (filters->size() > 0)
{
filterPtr = (*filters)[0];
}
}
}
TransportProtocol protocol = Tp_Unspecified;
if (!filterPtr)
{
protocol = Tp_Clear;
}
else
{
int filterId = filterPtr->getFilterId();
switch (filterId)
{
case RcfFilter_SspiNtlm: protocol = Tp_Ntlm; break;
case RcfFilter_SspiKerberos: protocol = Tp_Kerberos; break;
case RcfFilter_SspiNegotiate: protocol = Tp_Negotiate; break;
case RcfFilter_SspiSchannel: protocol = Tp_Ssl; break;
case RcfFilter_OpenSsl: protocol = Tp_Ssl; break;
default: protocol = Tp_Unspecified; break;
}
}
// Check that the filter sequence is allowed.
const std::vector<TransportProtocol> & protocols = server.getSupportedTransportProtocols();
if (protocols.size() > 0)
{
if (std::find(protocols.begin(), protocols.end(), protocol) == protocols.end())
{
RCF_THROW( Exception(_RcfError_ProtocolNotSupported()) );
}
}
if (protocol != Tp_Unspecified)
{
session.mTransportProtocol = protocol;
}
if (session.transportFiltersLocked())
{
RCF_LOG_3() << "FilterService::RequestTransportFilters() - filter sequence already locked.";
return RcfError_FiltersLocked;
}
else
{
session.addOnWriteCompletedCallback( boost::bind(
&FilterService::setTransportFilters,
this,
_1,
filters) );
}
RCF_LOG_3() << "FilterService::RequestTransportFilters() - exit";
return RcfError_Ok;
}
void FiltersWidget::appendFilterIfWanted(FilterPtr filter)
{
if(mWantedFilters.empty() || mWantedFilters.contains(filter->getName()))
mFilters->append(filter);
}
