double EffectTruncSilence::CalcPreviewInputLength(double /* previewLength */)
{
double inputLength = mT1 - mT0;
double minInputLength = inputLength;
// Master list of silent regions
RegionList silences;
// Start with the whole selection silent
silences.push_back(Region(mT0, mT1));
SelectedTrackListOfKindIterator iter(Track::Wave, mTracks);
int whichTrack = 0;
for (Track *t = iter.First(); t; t = iter.Next()) {
WaveTrack *const wt = static_cast<WaveTrack *>(t);
RegionList trackSilences;
sampleCount index = wt->TimeToLongSamples(mT0);
sampleCount silentFrame = 0; // length of the current silence
Analyze(silences, trackSilences, wt, &silentFrame, &index, whichTrack, &inputLength, &minInputLength);
whichTrack++;
}
return inputLength;
}
RegionList ParallelSelector::getRegions(const core::NodePtr& node) const {
RegionList res;
auto parallel = node->getNodeManager().getLangBasic().getParallel();
core::visitDepthFirst(core::NodeAddress(node), [&](const core::CallExprAddress& cur)->bool {
if (*cur.getAddressedNode()->getFunctionExpr() != *parallel) {
return false;
}
core::JobExprAddress job = cur->getArgument(0).as<core::JobExprAddress>();
core::ExpressionAddress addr = job->getBody();
if(addr->getNodeType() == core::NT_BindExpr) {
addr = addr.as<core::BindExprAddress>()->getCall()->getFunctionExpr();
}
if (addr->getNodeType() == core::NT_LambdaExpr) {
res.push_back(addr.as<core::LambdaExprAddress>()->getBody());
}
return true;
}, false);
return res;
}
ProgramStateRef
ProgramState::invalidateRegions(RegionList Regions,
const Expr *E, unsigned Count,
const LocationContext *LCtx,
bool CausedByPointerEscape,
InvalidatedSymbols *IS,
const CallEvent *Call,
RegionList ConstRegions) const {
SmallVector<SVal, 8> Values;
for (RegionList::const_iterator I = Regions.begin(),
End = Regions.end(); I != End; ++I)
Values.push_back(loc::MemRegionVal(*I));
SmallVector<SVal, 8> ConstValues;
for (RegionList::const_iterator I = ConstRegions.begin(),
End = ConstRegions.end(); I != End; ++I)
ConstValues.push_back(loc::MemRegionVal(*I));
if (!IS) {
InvalidatedSymbols invalidated;
return invalidateRegionsImpl(Values, E, Count, LCtx,
CausedByPointerEscape,
invalidated, Call, ConstValues);
}
return invalidateRegionsImpl(Values, E, Count, LCtx, CausedByPointerEscape,
*IS, Call, ConstValues);
}
void boundaries()
{
//define the boundaries
RegionList *regionList = GetBoundaries();
cl_int *regionIndeces = regionList->GetRegionIndeces(0);
cl_int numRegions = regionList->GetNumRegions();
numBoundaries_ = 0;
for(cl_int i = 0; i < numRegions; i++) {
numBoundaries_ += regionList->GetRegionCount(i);
}
boundaries_ = new cl_int [numBoundaries_];
for(cl_int i = 0; i < numBoundaries_; i++) {
boundaries_[i] = regionIndeces[i];
}
memset(h_bndy, 255, height * width * sizeof(cl_uchar));
for(cl_int i = 0; i < numBoundaries_; i++) {
h_bndy[boundaries_[i]] = 0;
}
}
bool EffectTruncSilence::FindSilences
(RegionList &silences, Track *firstTrack, Track *lastTrack)
{
// Start with the whole selection silent
Region *sel = new Region;
sel->start = mT0;
sel->end = mT1;
silences.push_back(sel);
// Remove non-silent regions in each track
SelectedTrackListOfKindIterator iter(Track::Wave, mTracks);
int whichTrack = 0;
bool lastSeen = false;
for (Track *t = iter.StartWith(firstTrack); !lastSeen && t; t = iter.Next())
{
lastSeen = (t == lastTrack);
WaveTrack *const wt = static_cast<WaveTrack *>(t);
// Smallest silent region to detect in frames
sampleCount minSilenceFrames =
sampleCount(std::max(mInitialAllowedSilence, DEF_MinTruncMs) * wt->GetRate());
//
// Scan the track for silences
//
RegionList trackSilences;
trackSilences.DeleteContents(true);
sampleCount index = wt->TimeToLongSamples(mT0);
sampleCount silentFrame = 0;
// Detect silences
bool cancelled = !(Analyze(silences, trackSilences, wt, &silentFrame, &index, whichTrack));
// Buffer has been freed, so we're OK to return if cancelled
if (cancelled)
{
ReplaceProcessedTracks(false);
return false;
}
if (silentFrame >= minSilenceFrames)
{
// Track ended in silence -- record region
Region *r = new Region;
r->start = wt->LongSamplesToTime(index - silentFrame);
r->end = wt->LongSamplesToTime(index);
trackSilences.push_back(r);
}
// Intersect with the overall silent region list
Intersect(silences, trackSilences);
whichTrack++;
}
return true;
}
RegionList PForSelector::getRegions(const core::NodePtr& node) const {
RegionList res;
auto pfor = node->getNodeManager().getLangExtension<lang::ParallelExtension>().getPFor();
core::visitDepthFirstPrunable(core::NodeAddress(node), [&](const core::CallExprAddress& cur) -> bool {
if(*cur.getAddressedNode()->getFunctionExpr() != *pfor) { return false; }
res.push_back(cur);
return true;
}, false);
return res;
}
void SubRegionList::addSubregion(SubRegion& toAdd)
{
_subregions.push_back(&toAdd);
//WARNING can i pass in region intersections as ouput? or perhaps i need to copy
if (_subregions.size() == 1)
_region_intersections = _subregions.front()->_regions;
else
{
RegionList tmp = _region_intersections;
tmp.intersectRegions(toAdd._regions, _region_intersections);
}
}
RegionList PForBodySelector::getRegions(const core::NodePtr& node) const {
RegionList res;
auto pfor = node->getNodeManager().getLangExtension<lang::ParallelExtension>().getPFor();
core::visitDepthFirstPrunable(core::NodeAddress(node), [&](const core::CallExprAddress& cur) -> bool {
if(*cur.getAddressedNode()->getFunctionExpr() != *pfor) { return false; }
core::ExpressionAddress body = cur->getArgument(4);
if(body->getNodeType() == core::NT_BindExpr) { body = body.as<core::BindExprAddress>()->getCall()->getFunctionExpr(); }
if(body->getNodeType() == core::NT_LambdaExpr) { res.push_back(body.as<core::LambdaExprAddress>()->getBody()); }
return true;
}, false);
return res;
}
RegionList SizeBasedRegionSelector::getRegions(const core::NodePtr& node) const {
RegionList regions;
SizeCalculator calculator;
visitDepthFirstPrunable(core::NodeAddress(node), [&](const core::CompoundStmtAddress &comp) {
unsigned size = calculator.estimateSize(comp.getAddressedNode());
if(minSize < size && size < maxSize) {
regions.push_back(comp);
return true;
}
return false;
});
return regions;
}
int CRegionManager::getRegionList(int cx,int cy,RegionList& list)
{
list.clear();
for ( size_t i = 0;i<m_Regions.size();++i )
{
CRegion* pRegion = m_Regions[i];
if ( pRegion && pRegion->containsCell(cx,cy ) )
{
list.push_back(pRegion);
}
}
return list.size();
}
bool EffectTruncSilence::ProcessAll()
{
// Copy tracks
CopyInputTracks(Track::All);
// Master list of silent regions; it is responsible for deleting them.
// This list should always be kept in order.
RegionList silences;
silences.DeleteContents(true);
SelectedTrackListOfKindIterator iter(Track::Wave, mTracks);
if (FindSilences(silences, iter.First(), iter.Last())) {
TrackListIterator iterOut(mOutputTracks);
double totalCutLen = 0.0;
Track *const first = iterOut.First();
if (DoRemoval(silences, 0, 1, first, iterOut.Last(), totalCutLen)) {
mT1 -= totalCutLen;
return true;
}
}
return false;
}
ProgramStateRef
ProgramState::invalidateRegionsImpl(RegionList Regions,
const Expr *E, unsigned Count,
const LocationContext *LCtx,
bool CausedByPointerEscape,
InvalidatedSymbols &IS,
const CallEvent *Call,
RegionList ConstRegions) const {
ProgramStateManager &Mgr = getStateManager();
SubEngine* Eng = Mgr.getOwningEngine();
InvalidatedSymbols ConstIS;
if (Eng) {
StoreManager::InvalidatedRegions Invalidated;
const StoreRef &newStore
= Mgr.StoreMgr->invalidateRegions(getStore(), Regions, E, Count, LCtx, IS,
Call, ConstRegions, ConstIS,
&Invalidated);
ProgramStateRef newState = makeWithStore(newStore);
if (CausedByPointerEscape) {
newState = Eng->notifyCheckersOfPointerEscape(newState,
&IS, Regions, Invalidated, Call);
if (!ConstRegions.empty()) {
StoreManager::InvalidatedRegions Empty;
newState = Eng->notifyCheckersOfPointerEscape(newState, &ConstIS,
ConstRegions, Empty, Call,
true);
}
}
return Eng->processRegionChanges(newState, &IS, Regions, Invalidated, Call);
}
const StoreRef &newStore =
Mgr.StoreMgr->invalidateRegions(getStore(), Regions, E, Count, LCtx, IS,
Call, ConstRegions, ConstIS, NULL);
return makeWithStore(newStore);
}
void BlockCall::getExtraInvalidatedRegions(RegionList &Regions) const {
// FIXME: This also needs to invalidate captured globals.
if (const MemRegion *R = getBlockRegion())
Regions.push_back(R);
}
void CXXInstanceCall::getExtraInvalidatedRegions(RegionList &Regions) const {
if (const MemRegion *R = getCXXThisVal().getAsRegion())
Regions.push_back(R);
}
bool EffectTruncSilence::ProcessIndependently()
{
unsigned nGroups = 0;
const bool syncLock = ::GetActiveProject()->IsSyncLocked();
// Check if it's permissible
{
SelectedTrackListOfKindIterator iter(Track::Wave, mTracks);
for (Track *track = iter.First(); track;
track = iter.Next(true) // skip linked tracks
) {
if (syncLock) {
Track *const link = track->GetLink();
SyncLockedTracksIterator syncIter(mTracks);
for (Track *track2 = syncIter.First(track); track2; track2 = syncIter.Next()) {
if (track2->GetKind() == Track::Wave &&
!(track2 == track || track2 == link) &&
track2->GetSelected()) {
::wxMessageBox(_("When truncating independently, there may only be one selected audio track in each sync-lock group."));
return false;
}
}
}
++nGroups;
}
}
if (nGroups == 0)
// nothing to do
return true;
// Now do the work
// Copy tracks
CopyInputTracks(Track::All);
double newT1 = 0.0;
{
unsigned iGroup = 0;
SelectedTrackListOfKindIterator iter(Track::Wave, mOutputTracks);
for (Track *track = iter.First(); track;
++iGroup, track = iter.Next(true) // skip linked tracks
) {
Track *const link = track->GetLink();
Track *const last = link ? link : track;
RegionList silences;
silences.DeleteContents(true);
if (!FindSilences(silences, track, last))
return false;
// Treat tracks in the sync lock group only
Track *groupFirst, *groupLast;
if (syncLock) {
SyncLockedTracksIterator syncIter(mOutputTracks);
groupFirst = syncIter.First(track);
groupLast = syncIter.Last(track);
}
else {
groupFirst = track;
groupLast = last;
}
double totalCutLen = 0.0;
if (!DoRemoval(silences, iGroup, nGroups, groupFirst, groupLast, totalCutLen))
return false;
newT1 = std::max(newT1, mT1 - totalCutLen);
}
}
mT1 = newT1;
return true;
}
int main(int argc,
char* argv[])
{
int ret = 0;
RegionList regions;
if (argc < 3) {
std::cout << "Usage: " << argv[0] << " <RAW file> <BRL-CAD file>" << std::endl;
ret = 1;
}
else {
std::ifstream is(argv[1]);
if (!is.is_open()) {
std::cout << "Error reading RAW file" << std::endl;
ret = 1;
}
else {
struct rt_wdb* wdbp = wdb_fopen(argv[2]);
std::string title = "Converted from ";
title += argv[1];
mk_id(wdbp, title.c_str());
std::vector<std::string> nameLine = readLine(is);
while (is && !is.eof()) {
if (nameLine.size() == 0) {
nameLine = readLine(is);
continue;
}
std::cout << "Read: " << nameLine[0].c_str() << '\n';
assert(nameLine[0].size() > 0);
Bot& bot = regions.addRegion(nameLine[0]);
if (nameLine.size() > 1) {
size_t thicknessIndex = nameLine[1].find("thickf=");
if (thicknessIndex != std::string::npos) {
std::string thickf = nameLine[1].substr(thicknessIndex + 7);
if (thickf.size() > 0) {
fastf_t val = toValue(thickf.c_str());
bot.setThickness(val);
} else {
std::cout << "Missing thickness in " << nameLine[0].c_str() << '\n';
}
}
}
std::vector<std::string> triangleLine = readLine(is);
while (is && (triangleLine.size() == 9)) {
point_t p;
getPoint(triangleLine[0], triangleLine[1], triangleLine[2], p);
size_t a = bot.addPoint(p);
getPoint(triangleLine[3], triangleLine[4], triangleLine[5], p);
size_t b = bot.addPoint(p);
getPoint(triangleLine[6], triangleLine[7], triangleLine[8], p);
size_t c = bot.addPoint(p);
bot.addTriangle(a, b, c);
triangleLine = readLine(is);
}
nameLine = triangleLine;
}
regions.create(wdbp);
wdb_close(wdbp);
}
}
regions.printStat();
return ret;
}
bool EffectTruncSilence::Analyze(RegionList& silenceList,
RegionList& trackSilences,
WaveTrack* wt,
sampleCount* silentFrame,
sampleCount* index,
int whichTrack,
double* inputLength /*= NULL*/,
double* minInputLength /*= NULL*/)
{
// Smallest silent region to detect in frames
sampleCount minSilenceFrames = sampleCount(std::max( mInitialAllowedSilence, DEF_MinTruncMs) * wt->GetRate());
double truncDbSilenceThreshold = Enums::Db2Signal[mTruncDbChoiceIndex];
sampleCount blockLen = wt->GetMaxBlockSize();
sampleCount start = wt->TimeToLongSamples(mT0);
sampleCount end = wt->TimeToLongSamples(mT1);
sampleCount outLength = 0;
double previewLength;
gPrefs->Read(wxT("/AudioIO/EffectsPreviewLen"), &previewLength, 6.0);
// Minimum required length in samples.
const sampleCount previewLen = previewLength * wt->GetRate();
// Keep position in overall silences list for optimization
RegionList::iterator rit(silenceList.begin());
// Allocate buffer
float *buffer = new float[blockLen];
// Loop through current track
while (*index < end) {
if (inputLength && ((outLength >= previewLen) || (*index - start > wt->TimeToLongSamples(*minInputLength)))) {
*inputLength = std::min<double>(*inputLength, *minInputLength);
if (outLength >= previewLen) {
*minInputLength = *inputLength;
}
return true;
}
if (!inputLength) {
// Show progress dialog, test for cancellation
bool cancelled = TotalProgress(
detectFrac * (whichTrack + (*index - start) / (double)(end - start)) /
(double)GetNumWaveTracks());
if (cancelled) {
delete [] buffer;
return false;
}
}
// Optimization: if not in a silent region skip ahead to the next one
double curTime = wt->LongSamplesToTime(*index);
for ( ; rit != silenceList.end(); ++rit) {
// Find the first silent region ending after current time
if (rit->end >= curTime) {
break;
}
}
if (rit == silenceList.end()) {
// No more regions -- no need to process the rest of the track
if (inputLength) {
// Add available samples up to previewLength.
sampleCount remainingTrackSamples = wt->TimeToLongSamples(wt->GetEndTime()) - *index;
sampleCount requiredTrackSamples = previewLen - outLength;
outLength += (remainingTrackSamples > requiredTrackSamples)? requiredTrackSamples : remainingTrackSamples;
}
break;
}
else if (rit->start > curTime) {
// End current silent region, skip ahead
if (*silentFrame >= minSilenceFrames) {
trackSilences.push_back(Region(
wt->LongSamplesToTime(*index - *silentFrame),
wt->LongSamplesToTime(*index)
));
}
*silentFrame = 0;
sampleCount newIndex = wt->TimeToLongSamples(rit->start);
if (inputLength) {
sampleCount requiredTrackSamples = previewLen - outLength;
// Add non-silent sample to outLength
outLength += ((newIndex - *index) > requiredTrackSamples)? requiredTrackSamples : newIndex - *index;
}
*index = newIndex;
}
// End of optimization
// Limit size of current block if we've reached the end
sampleCount count = blockLen;
if ((*index + count) > end) {
count = end - *index;
}
// Fill buffer
wt->Get((samplePtr)(buffer), floatSample, *index, count);
// Look for silenceList in current block
for (sampleCount i = 0; i < count; ++i) {
if (inputLength && ((outLength >= previewLen) || (outLength > wt->TimeToLongSamples(*minInputLength)))) {
*inputLength = wt->LongSamplesToTime(*index + i) - wt->LongSamplesToTime(start);
break;
}
if (fabs(buffer[i]) < truncDbSilenceThreshold) {
(*silentFrame)++;
}
else {
sampleCount allowed = 0;
if (*silentFrame >= minSilenceFrames) {
if (inputLength) {
switch (mActionIndex) {
case kTruncate:
outLength += wt->TimeToLongSamples(mTruncLongestAllowedSilence);
break;
case kCompress:
allowed = wt->TimeToLongSamples(mInitialAllowedSilence);
outLength += allowed +
(*silentFrame - allowed) * mSilenceCompressPercent / 100.0;
break;
// default: // Not currently used.
}
}
// Record the silent region
Region *r = new Region;
r->start = wt->LongSamplesToTime(*index + i - *silentFrame);
r->end = wt->LongSamplesToTime(*index + i);
trackSilences.push_back(Region(
wt->LongSamplesToTime(*index + i - *silentFrame),
wt->LongSamplesToTime(*index + i)
));
}
else if (inputLength) { // included as part of non-silence
outLength += *silentFrame;
}
*silentFrame = 0;
if (inputLength) {
++outLength; // Add non-silent sample to outLength
}
}
}
// Next block
*index += count;
}
delete [] buffer;
if (inputLength) {
*inputLength = std::min<double>(*inputLength, *minInputLength);
if (outLength >= previewLen) {
*minInputLength = *inputLength;
}
}
return true;
}
void petabricks::CodeGenerator::mkCreateGpuSpatialMethodCallTask(
const std::string& transname,
const std::string& taskname,
const std::string& objname,
const std::string& methodname,
const SimpleRegion& region,
std::vector<RegionNodeGroup>& regionNodesGroups,
int nodeID,
int gpuCopyOut,
RegionList to,
bool divisible) {
std::string taskclass
;
int dim_int = region.totalDimensions();
std::string lastdim = jalib::XToString(dim_int - 1);
std::string max = region.maxCoord()[dim_int - 1]->toString();
std::string min = region.minCoord()[dim_int - 1]->toString();
if(!divisible) {
taskclass = "petabricks::CreateGpuSpatialMethodCallTask<"+objname
+ ", " + jalib::XToString(region.totalDimensions())
+ ", &" + objname + "::" + methodname + TX_OPENCL_POSTFIX + "_createtasks"
+ ">";
//beginIf(min+"<"+max);
comment("MARKER 6");
write("IndexT _tmp_begin[] = {" + region.getIterationLowerBounds() + "};");
write("IndexT _tmp_end[] = {" + region.getIterationUpperBounds() + "};");
write("RegionNodeGroupMapPtr groups = new RegionNodeGroupMap();");
for(std::vector<RegionNodeGroup>::iterator group = regionNodesGroups.begin(); group != regionNodesGroups.end(); ++group){
write("{");
incIndent();
write("std::set<int> ids;");
for(std::vector<int>::iterator id = group->nodeIDs().begin(); id != group->nodeIDs().end(); ++id){
write("ids.insert("+jalib::XToString(*id)+");");
}
write("groups->insert(RegionNodeGroup(\""+group->matrixName()+"\",ids));");
decIndent();
write("}");
}
write(taskname+" = new "+taskclass+"(this,_tmp_begin, _tmp_end, "+jalib::XToString(nodeID)+", groups, "+jalib::XToString(gpuCopyOut)+");");
//endIf();
return;
}
std::string n_div = "cont_" + jalib::XToString(_contCounter++);
write(taskname + " = new petabricks::MethodCallTask<"+_curClass+", &"+_curClass+"::"+n_div+">( this );");
// Add divider function
CodeGenerator helper = forkhelper();
helper.beginFunc("DynamicTaskPtr", n_div);
helper.write("DynamicTaskPtr _fini = new NullDynamicTask();");
// Assign the gpu-cpu division point.
helper.write("ElementT gpu_ratio = "+transname+"_gpuratio/8.0;");
std::string div = "div";
RegionPtr proxy = to.front();
helper.write("IndexT totalRow = "+proxy->matrix()->name()+".size("+jalib::XToString(dim_int - 1)+");");
helper.write("IndexT div = ceil(gpu_ratio * totalRow);");
helper.beginIf("div > " + max);
helper.write("div = "+max+";");
helper.endIf();
// GPU
taskclass = "petabricks::CreateGpuSpatialMethodCallTask<"+objname
+ ", " + jalib::XToString(dim_int)
+ ", &" + objname + "::" + methodname + TX_OPENCL_POSTFIX + "_createtasks"
+ ">";
helper.comment("MARKER 6");
//helper.beginIf(min+" < div");
helper.write("IndexT _gpu_begin[] = {" + region.getIterationLowerBounds() + "};");
helper.write("IndexT _gpu_end[] = {" + region.getIterationMiddleEnd(div) + "};");
helper.write("RegionNodeGroupMapPtr groups = new RegionNodeGroupMap();");
for(std::vector<RegionNodeGroup>::iterator group = regionNodesGroups.begin(); group != regionNodesGroups.end(); ++group){
helper.write("{");
helper.incIndent();
helper.write("std::set<int> ids;");
for(std::vector<int>::iterator id = group->nodeIDs().begin(); id != group->nodeIDs().end(); ++id){
helper.write("ids.insert("+jalib::XToString(*id)+");");
}
helper.write("groups->insert(RegionNodeGroup(\""+group->matrixName()+"\",ids));");
helper.decIndent();
helper.write("}");
}
helper.write("DynamicTaskPtr gpu_task = new "+taskclass+"(this,_gpu_begin, _gpu_end, "+jalib::XToString(nodeID)+", groups, "+jalib::XToString(gpuCopyOut)+");");
helper.write("gpu_task->enqueue();");
helper.write("_fini->dependsOn(gpu_task);");
//helper.endIf();
// CPU
taskclass = "petabricks::SpatialMethodCallTask<CLASS"
", " + jalib::XToString(dim_int)
+ ", &CLASS::" + methodname + "_workstealing_wrap"
//+ ", &CLASS::" + methodname + "_workstealing"
+ ">";
helper.beginIf("div < " + max);
helper.beginIf("div < " + min);
helper.write("div = "+min+";");
helper.endIf();
helper.comment("MARKER 6");
helper.write("IndexT _cpu_begin[] = {" + region.getIterationMiddleBegin(div) + "};");
helper.write("IndexT _cpu_end[] = {" + region.getIterationUpperBounds() + "};");
helper.write("DynamicTaskPtr cpu_task = new "+taskclass+"(this,_cpu_begin, _cpu_end);");
helper.write("cpu_task->enqueue();");
helper.write("_fini->dependsOn(cpu_task);");
helper.endIf();
helper.write("return _fini;");
helper.endFunc();
}
void CXXDestructorCall::addExtraInvalidatedRegions(RegionList &Regions) const {
if (Target)
Regions.push_back(Target);
}
void
CXXMemberOperatorCall::addExtraInvalidatedRegions(RegionList &Regions) const {
if (const MemRegion *R = getCXXThisVal().getAsRegion())
Regions.push_back(R);
}
void CXXDestructorCall::getExtraInvalidatedRegions(RegionList &Regions) const {
if (Data)
Regions.push_back(static_cast<const MemRegion *>(Data));
}
void
ObjCMethodCall::getExtraInvalidatedRegions(RegionList &Regions) const {
if (const MemRegion *R = getReceiverSVal().getAsRegion())
Regions.push_back(R);
}
int main(int argc, char** argv)
{
ros::init(argc, argv, "ENGR301");
ImageFetcher input_stream("in");
int sequence_number;
bool measuring = false;
cv::Mat frame;
cv::Mat frame_copy;
RegionList contours;
int max_size,max_at;
int max_height;
double scale_factor = 1;
int setpoint = 480;
std::string print;
double pendulum_height = 0;
while(ros::ok()) {
ros::spinOnce();
sequence_number = input_stream.GetFrame(frame);
if(sequence_number!=0) {
if(measuring) {
//initialize it to a reasonably large value to remove noise
max_size = 2000;
max_at = -1;
//get blobs from the image
//need to copy the frame because findContours destroys it :(
frame.copyTo(frame_copy);
cv::findContours(frame_copy,contours,CV_RETR_EXTERNAL,CV_CHAIN_APPROX_NONE);
for(int i=0;i<contours.size();i++) {
if(cv::contourArea(contours[i]) > max_size) {
max_size = cv::contourArea(contours[i]);
max_at = i;
}
}
//now I know where the biggest contour is
if(max_at!=-1) {
//find the bottom of this contour
cv::Rect bound = cv::boundingRect(contours[max_at]);
//note that in the camera frame up is negative
if(bound.y+bound.height < max_height) {
//this is the new pinacle
max_height = bound.y+bound.height-PUCK_SIZE;
}
}
cv::line(frame,cv::Point(0,max_height),cv::Point(frame.cols-1,max_height),cv::Scalar(255,0,0),2,8);
pendulum_height = (setpoint-max_height)*scale_factor;
}
std::stringstream text;
text << pendulum_height;
cv::putText(frame,text.str(),cv::Point(150,max_height-10),CV_FONT_HERSHEY_SIMPLEX,3,cv::Scalar(255,0,0),2,8);
cv::line(frame,cv::Point(0,setpoint),cv::Point(frame.cols-1,setpoint),cv::Scalar(255),2,8);
std::cout<<"Height: "<<pendulum_height<<std::endl;
imshow("window",frame);
}
switch(cv::waitKey(1)) {
case 'm':
measuring = !measuring;
max_height = setpoint;
break;
case 'w':
//adjust setpoint up
setpoint +=1;
std::cout<<"setpoint: "<<setpoint<<std::endl;
break;
case 's':
//adjust setpoint donw
setpoint -=1;
std::cout<<"setpoint: "<<setpoint<<std::endl;
break;
case 't':
//train on a piece of paper
//get contours in the frame and find the biggest one
std::cout<<"finding contours"<<std::endl;
cv::findContours(frame,contours,CV_RETR_EXTERNAL,CV_CHAIN_APPROX_NONE);
std::cout<<"found contours"<<std::endl;
max_at = -1;
for(int i=0;i<contours.size();i++) {
if(cv::contourArea(contours[i]) > max_size) {
std::cout<<"finding area"<<std::endl;
max_size = cv::contourArea(contours[i]);
max_at = i;
}
}
std::cout<<"found max"<<std::endl;
//now I know where the biggest contour is
if(max_at!=-1) {
//find the bound of this contour
std::cout<<"calcing bound: "<<contours[max_at]<<std::endl;
cv::Rect bound = cv::boundingRect(contours[max_at]);
std::cout<<"calced bound"<<std::endl;
//I know the piece of paper is 8.5 inches wide and the width of this blob
//so now I have a scale factor
scale_factor = 0.2196/bound.width;
std::cout<<"bound width: "<<bound.width<<std::endl;
std::cout<<"scale factor: "<<scale_factor<<std::endl;
}
break;
}
}
return 0;
}
bool EffectTruncSilence::DoRemoval
(const RegionList &silences, unsigned iGroup, unsigned nGroups, Track *firstTrack, Track *lastTrack,
double &totalCutLen)
{
//
// Now remove the silent regions from all selected / sync-lock selected tracks.
//
// Loop over detected regions in reverse (so cuts don't change time values
// down the line)
int whichReg = 0;
RegionList::const_reverse_iterator rit;
for (rit = silences.rbegin(); rit != silences.rend(); ++rit)
{
const Region ®ion = *rit;
const Region *const r = ®ion;
// Progress dialog and cancellation. Do additional cleanup before return.
const double frac = detectFrac +
(1 - detectFrac) * (iGroup + whichReg / double(silences.size())) / nGroups;
if (TotalProgress(frac))
{
ReplaceProcessedTracks(false);
return false;
}
// Intersection may create regions smaller than allowed; ignore them.
// Allow one nanosecond extra for consistent results with exact milliseconds of allowed silence.
if ((r->end - r->start) < (mInitialAllowedSilence - 0.000000001))
continue;
// Find NEW silence length as requested
double inLength = r->end - r->start;
double outLength;
switch (mActionIndex)
{
case kTruncate:
outLength = std::min(mTruncLongestAllowedSilence, inLength);
break;
case kCompress:
outLength = mInitialAllowedSilence +
(inLength - mInitialAllowedSilence) * mSilenceCompressPercent / 100.0;
break;
default: // Not currently used.
outLength = std::min(mInitialAllowedSilence +
(inLength - mInitialAllowedSilence) * mSilenceCompressPercent / 100.0,
mTruncLongestAllowedSilence);
}
double cutLen = inLength - outLength;
totalCutLen += cutLen;
TrackListIterator iterOut(mOutputTracks);
bool lastSeen = false;
for (Track *t = iterOut.StartWith(firstTrack); t && !lastSeen; t = iterOut.Next())
{
lastSeen = (t == lastTrack);
if (!(t->GetSelected() || t->IsSyncLockSelected()))
continue;
// Don't waste time past the end of a track
if (t->GetEndTime() < r->start)
continue;
double cutStart = (r->start + r->end - cutLen) / 2;
double cutEnd = cutStart + cutLen;
if (t->GetKind() == Track::Wave)
{
// In WaveTracks, clear with a cross-fade
WaveTrack *const wt = static_cast<WaveTrack*>(t);
sampleCount blendFrames = mBlendFrameCount;
// Round start/end times to frame boundaries
cutStart = wt->LongSamplesToTime(wt->TimeToLongSamples(cutStart));
cutEnd = wt->LongSamplesToTime(wt->TimeToLongSamples(cutEnd));
// Make sure the cross-fade does not affect non-silent frames
if (wt->LongSamplesToTime(blendFrames) > inLength)
{
blendFrames = wt->TimeToLongSamples(inLength);
}
// Perform cross-fade in memory
float *buf1 = new float[blendFrames];
float *buf2 = new float[blendFrames];
sampleCount t1 = wt->TimeToLongSamples(cutStart) - blendFrames / 2;
sampleCount t2 = wt->TimeToLongSamples(cutEnd) - blendFrames / 2;
wt->Get((samplePtr)buf1, floatSample, t1, blendFrames);
wt->Get((samplePtr)buf2, floatSample, t2, blendFrames);
for (sampleCount i = 0; i < blendFrames; ++i)
{
buf1[i] = ((blendFrames-i) * buf1[i] + i * buf2[i]) /
(double)blendFrames;
}
// Perform the cut
wt->Clear(cutStart, cutEnd);
// Write cross-faded data
wt->Set((samplePtr)buf1, floatSample, t1, blendFrames);
delete [] buf1;
delete [] buf2;
}
else
// Non-wave tracks: just do a sync-lock adjust
t->SyncLockAdjust(cutEnd, cutStart);
}
++whichReg;
}
return true;
}
bool EffectTruncSilence::Process()
{
// Typical fraction of total time taken by detection (better to guess low)
const double detectFrac = .4;
// Copy tracks
this->CopyInputTracks(Track::All);
// Lower bound on the amount of silence to find at a time -- this avoids
// detecting silence repeatedly in low-frequency sounds.
const double minTruncMs = 0.001;
double truncDbSilenceThreshold = Enums::Db2Signal[mTruncDbChoiceIndex];
// Master list of silent regions; it is responsible for deleting them.
// This list should always be kept in order.
RegionList silences;
silences.DeleteContents(true);
// Start with the whole selection silent
Region *sel = new Region;
sel->start = mT0;
sel->end = mT1;
silences.push_back(sel);
// Remove non-silent regions in each track
SelectedTrackListOfKindIterator iter(Track::Wave, mTracks);
int whichTrack = 0;
for (Track *t = iter.First(); t; t = iter.Next())
{
WaveTrack *wt = (WaveTrack *)t;
// Smallest silent region to detect in frames
sampleCount minSilenceFrames =
sampleCount(wxMax( mInitialAllowedSilence, minTruncMs) *
wt->GetRate());
//
// Scan the track for silences
//
RegionList trackSilences;
trackSilences.DeleteContents(true);
sampleCount blockLen = wt->GetMaxBlockSize();
sampleCount start = wt->TimeToLongSamples(mT0);
sampleCount end = wt->TimeToLongSamples(mT1);
// Allocate buffer
float *buffer = new float[blockLen];
sampleCount index = start;
sampleCount silentFrames = 0;
bool cancelled = false;
// Keep position in overall silences list for optimization
RegionList::iterator rit(silences.begin());
while (index < end) {
// Show progress dialog, test for cancellation
cancelled = TotalProgress(
detectFrac * (whichTrack + index / (double)end) /
(double)GetNumWaveTracks());
if (cancelled)
break;
//
// Optimization: if not in a silent region skip ahead to the next one
//
double curTime = wt->LongSamplesToTime(index);
for ( ; rit != silences.end(); ++rit)
{
// Find the first silent region ending after current time
if ((*rit)->end >= curTime)
break;
}
if (rit == silences.end()) {
// No more regions -- no need to process the rest of the track
break;
}
else if ((*rit)->start > curTime) {
// End current silent region, skip ahead
if (silentFrames >= minSilenceFrames) {
Region *r = new Region;
r->start = wt->LongSamplesToTime(index - silentFrames);
r->end = wt->LongSamplesToTime(index);
trackSilences.push_back(r);
}
silentFrames = 0;
index = wt->TimeToLongSamples((*rit)->start);
}
//
// End of optimization
//
// Limit size of current block if we've reached the end
sampleCount count = blockLen;
if ((index + count) > end) {
count = end - index;
}
// Fill buffer
wt->Get((samplePtr)(buffer), floatSample, index, count);
// Look for silences in current block
for (sampleCount i = 0; i < count; ++i) {
if (fabs(buffer[i]) < truncDbSilenceThreshold) {
++silentFrames;
}
else {
if (silentFrames >= minSilenceFrames)
{
// Record the silent region
Region *r = new Region;
r->start = wt->LongSamplesToTime(index + i - silentFrames);
r->end = wt->LongSamplesToTime(index + i);
trackSilences.push_back(r);
}
silentFrames = 0;
}
}
// Next block
index += count;
}
delete [] buffer;
// Buffer has been freed, so we're OK to return if cancelled
if (cancelled)
{
ReplaceProcessedTracks(false);
return false;
}
if (silentFrames >= minSilenceFrames)
{
// Track ended in silence -- record region
Region *r = new Region;
r->start = wt->LongSamplesToTime(index - silentFrames);
r->end = wt->LongSamplesToTime(index);
trackSilences.push_back(r);
}
// Intersect with the overall silent region list
Intersect(silences, trackSilences);
whichTrack++;
}
//
// Now remove the silent regions from all selected / sync-lock selected tracks.
//
// Loop over detected regions in reverse (so cuts don't change time values
// down the line)
int whichReg = 0;
RegionList::reverse_iterator rit;
double totalCutLen = 0.0; // For cutting selection at the end
for (rit = silences.rbegin(); rit != silences.rend(); ++rit) {
Region *r = *rit;
// Progress dialog and cancellation. Do additional cleanup before return.
if (TotalProgress(detectFrac + (1 - detectFrac) * whichReg / (double)silences.size()))
{
ReplaceProcessedTracks(false);
return false;
}
// Intersection may create regions smaller than allowed; ignore them.
// Allow one nanosecond extra for consistent results with exact milliseconds of allowed silence.
if ((r->end - r->start) < (mInitialAllowedSilence - 0.000000001))
continue;
// Find new silence length as requested
double inLength = r->end - r->start;
double outLength;
switch (mProcessIndex) {
case 0:
outLength = wxMin(mTruncLongestAllowedSilence, inLength);
break;
case 1:
outLength = mInitialAllowedSilence +
(inLength - mInitialAllowedSilence) * mSilenceCompressPercent / 100.0;
break;
default: // Not currently used.
outLength = wxMin(mInitialAllowedSilence +
(inLength - mInitialAllowedSilence) * mSilenceCompressPercent / 100.0,
mTruncLongestAllowedSilence);
}
double cutLen = inLength - outLength;
totalCutLen += cutLen;
TrackListIterator iterOut(mOutputTracks);
for (Track *t = iterOut.First(); t; t = iterOut.Next())
{
// Don't waste time past the end of a track
if (t->GetEndTime() < r->start)
continue;
if (t->GetKind() == Track::Wave && (
t->GetSelected() || t->IsSyncLockSelected()))
{
// In WaveTracks, clear with a cross-fade
WaveTrack *wt = (WaveTrack *)t;
sampleCount blendFrames = mBlendFrameCount;
double cutStart = (r->start + r->end - cutLen) / 2;
double cutEnd = cutStart + cutLen;
// Round start/end times to frame boundaries
cutStart = wt->LongSamplesToTime(wt->TimeToLongSamples(cutStart));
cutEnd = wt->LongSamplesToTime(wt->TimeToLongSamples(cutEnd));
// Make sure the cross-fade does not affect non-silent frames
if (wt->LongSamplesToTime(blendFrames) > inLength) {
blendFrames = wt->TimeToLongSamples(inLength);
}
// Perform cross-fade in memory
float *buf1 = new float[blendFrames];
float *buf2 = new float[blendFrames];
sampleCount t1 = wt->TimeToLongSamples(cutStart) - blendFrames / 2;
sampleCount t2 = wt->TimeToLongSamples(cutEnd) - blendFrames / 2;
wt->Get((samplePtr)buf1, floatSample, t1, blendFrames);
wt->Get((samplePtr)buf2, floatSample, t2, blendFrames);
for (sampleCount i = 0; i < blendFrames; ++i) {
buf1[i] = ((blendFrames-i) * buf1[i] + i * buf2[i]) /
(double)blendFrames;
}
// Perform the cut
wt->Clear(cutStart, cutEnd);
// Write cross-faded data
wt->Set((samplePtr)buf1, floatSample, t1, blendFrames);
delete [] buf1;
delete [] buf2;
}
else if (t->GetSelected() || t->IsSyncLockSelected())
{
// Non-wave tracks: just do a sync-lock adjust
double cutStart = (r->start + r->end - cutLen) / 2;
double cutEnd = cutStart + cutLen;
t->SyncLockAdjust(cutEnd, cutStart);
}
}
++whichReg;
}
mT1 -= totalCutLen;
ReplaceProcessedTracks(true);
return true;
}
// Finds the intersection of the ordered region lists, stores in dest
void EffectTruncSilence::Intersect(RegionList &dest, const RegionList &src)
{
RegionList::iterator destIter;
destIter = dest.begin();
// Any time we reach the end of the dest list we're finished
if (destIter == dest.end())
return;
RegionList::iterator curDest = destIter;
// Operation: find non-silent regions in src, remove them from dest.
double nsStart = curDest->start;
double nsEnd;
bool lastRun = false; // must run the loop one extra time
RegionList::const_iterator srcIter = src.begin();
// This logic, causing the loop to run once after end of src, must occur
// each time srcIter is updated
if (srcIter == src.end())
{
lastRun = true;
}
while (srcIter != src.end() || lastRun)
{
// Don't use curSrc unless lastRun is false!
RegionList::const_iterator curSrc;
if (lastRun)
{
// The last non-silent region extends as far as possible
nsEnd = std::numeric_limits<double>::max();
}
else
{
curSrc = srcIter;
nsEnd = curSrc->start;
}
if (nsEnd > nsStart)
{
// Increment through dest until we have a region that could be affected
while (curDest->end <= nsStart)
{
++destIter;
if (destIter == dest.end())
{
return;
}
curDest = destIter;
}
// Check for splitting dest region in two
if (nsStart > curDest->start && nsEnd < curDest->end)
{
// The second region
Region r(nsEnd, curDest->end);
// The first region
curDest->end = nsStart;
// Insert second region after first
RegionList::iterator nextIt(destIter);
++nextIt;
// This should just read: destIter = dest.insert(nextIt, r); but we
// work around two two wxList::insert() bugs. First, in some
// versions it returns the wrong value. Second, in some versions,
// it crashes when you insert at list end.
if (nextIt == dest.end())
dest.push_back(r);
else
dest.insert(nextIt, r);
++destIter; // (now points at the newly-inserted region)
curDest = destIter;
}
// Check for truncating the end of dest region
if (nsStart > curDest->start && nsStart < curDest->end &&
nsEnd >= curDest->end)
{
curDest->end = nsStart;
++destIter;
if (destIter == dest.end())
{
return;
}
curDest = destIter;
}
// Check for all dest regions that need to be removed completely
while (nsStart <= curDest->start && nsEnd >= curDest->end)
{
destIter = dest.erase(destIter);
if (destIter == dest.end())
{
return;
}
curDest = destIter;
}
// Check for truncating the beginning of dest region
if (nsStart <= curDest->start &&
nsEnd > curDest->start && nsEnd < curDest->end)
{
curDest->start = nsEnd;
}
}
if (lastRun)
{
// done
lastRun = false;
}
else
{
// Next non-silent region starts at the end of this silent region
nsStart = curSrc->end;
++srcIter;
if (srcIter == src.end())
{
lastRun = true;
}
}
}
}
//-------------------------------------------------------------------------------------------------
//-------------------------------------------------------------------------------------------------
RegionManager::RegionManager(const RegionList& rlist)
{
for (RegionList::const_iterator itr(rlist.begin()); itr != rlist.end(); ++itr)
_regions.insert(Regions::value_type(itr->second, new MemoryPool(itr->first, itr->second)));
}
