CallSpecifiedMultiProduct::CallSpecifiedMultiProduct(
const Clone<MarketModelMultiProduct>& underlying,
const Clone<ExerciseStrategy<CurveState> >& strategy,
const Clone<MarketModelMultiProduct>& rebate)
: underlying_(underlying),
strategy_(strategy),
rebate_(rebate),
callable_(true)
{
Size products = underlying_->numberOfProducts();
EvolutionDescription d1 = underlying->evolution();
const std::vector<Time>& rateTimes1 = d1.rateTimes();
const std::vector<Time>& evolutionTimes1 = d1.evolutionTimes();
const std::vector<Time>& exerciseTimes = strategy->exerciseTimes();
if (!rebate_.empty())
{
EvolutionDescription d2 = rebate_->evolution();
const std::vector<Time>& rateTimes2 = d2.rateTimes();
QL_REQUIRE(rateTimes1.size() == rateTimes2.size() &&
std::equal(rateTimes1.begin(), rateTimes1.end(),
rateTimes2.begin()),
"incompatible rate times");
}
else
{
EvolutionDescription description(rateTimes1, exerciseTimes);
Matrix amounts(products, exerciseTimes.size(), 0.0);
rebate_ = MarketModelCashRebate(description, exerciseTimes,
amounts, products);
}
std::vector<Time> mergedEvolutionTimes;
std::vector<std::vector<Time> > allEvolutionTimes(4);
allEvolutionTimes[0] = evolutionTimes1;
allEvolutionTimes[1] = exerciseTimes;
allEvolutionTimes[2] = rebate_->evolution().evolutionTimes();
allEvolutionTimes[3] = strategy->relevantTimes();
mergeTimes(allEvolutionTimes,
mergedEvolutionTimes,
isPresent_);
// TODO: add relevant rates
evolution_ = EvolutionDescription(rateTimes1, mergedEvolutionTimes);
cashFlowTimes_ = underlying_->possibleCashFlowTimes();
rebateOffset_ = cashFlowTimes_.size();
const std::vector<Time> rebateTimes = rebate_->possibleCashFlowTimes();
cashFlowTimes_.insert(cashFlowTimes_.end(),
rebateTimes.begin(), rebateTimes.end());
dummyCashFlowsThisStep_ = std::vector<Size>(products, 0);
Size n = rebate_->maxNumberOfCashFlowsPerProductPerStep();
dummyCashFlowsGenerated_ =
std::vector<std::vector<CashFlow> >(products,
std::vector<CashFlow>(n));
}
Clone makeClone(int pos[], sf::Texture *mctexture){
Clone clone;
sf::Sprite sprite;
sprite.setTexture(*mctexture);
sprite.setOrigin(TILE/2, TILE/2);
sprite.setPosition(TILE * (pos[0] + 0.5), TILE * (pos[1] + 0.5));
sprite.setTextureRect(sf::IntRect(4*TILE, TILE, TILE, TILE));
clone.setSprite(sprite);
clone.move_pos = 0;
return clone;
}
void FaceOff::updateClone()
{
gl::ScopedMatrices mvp;
gl::setMatricesWindow(mRenderedOfflineFaceFbo->getSize());
gl::ScopedViewport viewport(0, 0, mRenderedOfflineFaceFbo->getWidth(), mRenderedOfflineFaceFbo->getHeight());
// TODO: merge these two passes w/ MRTs
{
gl::ScopedFramebuffer fbo(mRenderedOfflineFaceFbo);
gl::ScopedGlslProg glsl(gl::getStockShader(gl::ShaderDef().texture()));
gl::ScopedTextureBind t0(mOfflineFaceTex, 0);
gl::clear(ColorA::black(), false);
gl::draw(mFaceMesh);
}
if (!MOVIE_MODE)
{
{
gl::ScopedFramebuffer fbo(mFaceMaskFbo);
gl::clear(ColorA::black(), false);
gl::draw(mFaceMesh);
}
// TODO: add gl::ScopedMatrices in mClone.update()
mClone.update(mRenderedOfflineFaceFbo->getColorTexture(), mCapture.texture, mFaceMaskFbo->getColorTexture());
mHasNewRenderedFace = true;
}
}
reg_t kDisposeClone(EngineState *s, int argc, reg_t *argv) {
reg_t obj = argv[0];
Clone *object = s->_segMan->getObject(obj);
if (!object) {
error("Attempt to dispose non-class/object at %04x:%04x",
PRINT_REG(obj));
return s->r_acc;
}
// SCI uses this technique to find out, if it's a clone and if it's supposed to get freed
// At least kq4early relies on this behavior. The scripts clone "Sound", then set bit 1 manually
// and call kDisposeClone later. In that case we may not free it, otherwise we will run into issues
// later, because kIsObject would then return false and Sound object wouldn't get checked.
uint16 infoSelector = object->getInfoSelector().toUint16();
if ((infoSelector & 3) == kInfoFlagClone)
object->markAsFreed();
return s->r_acc;
}
ProxyGreekEngine::ProxyGreekEngine(
const boost::shared_ptr<MarketModelEvolver>& evolver,
const std::vector<
std::vector<boost::shared_ptr<ConstrainedEvolver> > >&
constrainedEvolvers,
const std::vector<std::vector<std::vector<Real> > >& diffWeights,
const std::vector<Size>& startIndexOfConstraint,
const std::vector<Size>& endIndexOfConstraint,
const Clone<MarketModelMultiProduct>& product,
Real initialNumeraireValue)
: originalEvolver_(evolver), constrainedEvolvers_(constrainedEvolvers),
diffWeights_(diffWeights),
startIndexOfConstraint_(startIndexOfConstraint),
endIndexOfConstraint_(endIndexOfConstraint),
product_(product),
initialNumeraireValue_(initialNumeraireValue),
numberProducts_(product->numberOfProducts()),
numerairesHeld_(product->numberOfProducts()),
numberCashFlowsThisStep_(product->numberOfProducts()),
cashFlowsGenerated_(product->numberOfProducts()) {
for (Size i=0; i<numberProducts_; ++i)
cashFlowsGenerated_[i].resize(
product_->maxNumberOfCashFlowsPerProductPerStep());
const std::vector<Time>& cashFlowTimes =
product_->possibleCashFlowTimes();
const std::vector<Rate>& rateTimes = product_->evolution().rateTimes();
Size n = cashFlowTimes.size();
discounters_.reserve(n);
for (Size j=0; j<n; ++j)
discounters_.push_back(MarketModelDiscounter(cashFlowTimes[j],
rateTimes));
const std::vector<Rate>& evolutionTimes =
product_->evolution().evolutionTimes();
constraints_.resize(evolutionTimes.size());
constraintsActive_.resize(evolutionTimes.size());
}
reg_t kClone(EngineState *s, int argc, reg_t *argv) {
reg_t parentAddr = argv[0];
const Object *parentObj = s->_segMan->getObject(parentAddr);
reg_t cloneAddr;
Clone *cloneObj; // same as Object*
if (!parentObj) {
error("Attempt to clone non-object/class at %04x:%04x failed", PRINT_REG(parentAddr));
return NULL_REG;
}
debugC(kDebugLevelMemory, "Attempting to clone from %04x:%04x", PRINT_REG(parentAddr));
uint16 infoSelector = parentObj->getInfoSelector().toUint16();
cloneObj = s->_segMan->allocateClone(&cloneAddr);
if (!cloneObj) {
error("Cloning %04x:%04x failed-- internal error", PRINT_REG(parentAddr));
return NULL_REG;
}
// In case the parent object is a clone itself we need to refresh our
// pointer to it here. This is because calling allocateClone might
// invalidate all pointers, references and iterators to data in the clones
// segment.
//
// The reason why it might invalidate those is, that the segment code
// (Table) uses Common::Array for internal storage. Common::Array now
// might invalidate references to its contained data, when it has to
// extend the internal storage size.
if (infoSelector & kInfoFlagClone)
parentObj = s->_segMan->getObject(parentAddr);
*cloneObj = *parentObj;
// Mark as clone
infoSelector &= ~kInfoFlagClass; // remove class bit
cloneObj->setInfoSelector(make_reg(0, infoSelector | kInfoFlagClone));
cloneObj->setSpeciesSelector(cloneObj->getPos());
if (parentObj->isClass())
cloneObj->setSuperClassSelector(parentObj->getPos());
s->_segMan->getScript(parentObj->getPos().getSegment())->incrementLockers();
s->_segMan->getScript(cloneObj->getPos().getSegment())->incrementLockers();
return cloneAddr;
}
FByCloneHeap( Clone<A1> a ) // not ambiguous, cost is O(N) here and lifetime of a is whatever.
: myA1( a.allocate() )
{
std::cout << " FByCloneHeap( Clone<A1> a ) " << myA1 << std::endl;
}
inline void ExerciseAdapter::reset() {
exercise_->reset();
currentIndex_ = 0;
}
inline const EvolutionDescription& ExerciseAdapter::evolution() const {
return exercise_->evolution();
}
inline std::vector<Time>
ExerciseAdapter::possibleCashFlowTimes() const {
return exercise_->possibleCashFlowTimes();
}
inline DiscountFactor FittedBondDiscountCurve::discountImpl(Time t) const {
calculate();
return fittingMethod_->discountFunction(fittingMethod_->solution_, t);
}
void FaceOff::draw()
{
gl::clear(ColorA::black(), false);
if (!mCapture.isReady())
return;
gl::setMatricesWindow(getWindowSize());
gl::enableAlphaBlending();
float camAspect = CAM_W / (float)CAM_H;
float winAspect = getWindowAspectRatio();
float adaptiveCamW = 0;
float adaptiveCamH = 0;
if (camAspect > winAspect)
{
adaptiveCamW = APP_W;
adaptiveCamH = APP_W / camAspect;
}
else
{
adaptiveCamH = APP_H;
adaptiveCamW = APP_H * camAspect;
}
Area srcArea = { 0, 0, CAM_W, CAM_H };
Rectf dstRect =
{
APP_W * 0.5f - adaptiveCamW * 0.5f,
APP_H * 0.5f - adaptiveCamH * 0.5f,
APP_W * 0.5f + adaptiveCamW * 0.5f,
APP_H * 0.5f + adaptiveCamH * 0.5f
};
if (!mOnlineTracker)
{
gl::draw(mCapture.texture, srcArea, dstRect);
return;
}
gl::Texture2dRef fullscreenTex;
if (VFX_VISIBLE && mHasNewRenderedFace)
{
fullscreenTex = mClone.getResultTexture();
}
else if (VFX_VISIBLE && MOVIE_MODE)
{
fullscreenTex = mRenderedOfflineFaceFbo->getColorTexture();
}
else
{
fullscreenTex = mCapture.texture;
}
gl::draw(fullscreenTex, srcArea, dstRect);
if (OFFLINE_VISIBLE)
{
gl::draw(mOfflineFaceTex);
}
FPS = getAverageFps();
gl::disableAlphaBlending();
if (WIREFRAME_MODE && (MOVIE_MODE || mHasNewRenderedFace))
{
gl::enableWireframe();
gl::ScopedModelMatrix modelMatrix;
gl::ScopedColor color(ColorA(0, 1.0f, 0, 1.0f));
gl::translate(dstRect.x1, dstRect.y1);
gl::scale(adaptiveCamW / CAM_W, adaptiveCamH / CAM_H);
gl::draw(mFaceMesh);
if (OFFLINE_VISIBLE)
{
gl::draw(mOfflineTracker->getImageMesh());
}
gl::disableWireframe();
}
updateGui();
}
void FaceOff::trackerThreadFn()
{
jing::Option option;
option.scale = 0.5f;
mOfflineTracker = jing::BaseFaceTracker::create();
mOnlineTracker = jing::BaseFaceTracker::create(option);
bool shouldInitFaceMesh = false;
while (!mShouldQuit)
{
// TODO: more robust with update_signal
if (!mCapture.checkNewFrame())
{
sleep(1.0f);
continue;
}
if (mDoesCaptureNeedsInit)
{
// TODO: more robust with setup_signal
mDoesCaptureNeedsInit = false;
CAM_W = mCapture.size.x;
CAM_H = mCapture.size.y;
auto createFboFn = [this]
{
gl::Fbo::Format fboFormat;
fboFormat.enableDepthBuffer(false);
mRenderedOfflineFaceFbo = gl::Fbo::create(CAM_W, CAM_H, fboFormat);
mFaceMaskFbo = gl::Fbo::create(CAM_W, CAM_H, fboFormat);
mClone.setup(CAM_W, CAM_H);
mClone.setStrength(16);
};
dispatchAsync(createFboFn);
}
if (mPeopleId != PEOPLE_ID)
{
mPeopleId = PEOPLE_ID;
ImageSourceRef img = loadImage(loadAsset("people/" + mPeopleNames[PEOPLE_ID]));
updateOfflineImage(img);
shouldInitFaceMesh = true;
}
mOnlineTracker->update(mCapture.surface);
if (!mOnlineTracker->getFound())
{
mHasNewRenderedFace = false;
continue;
}
int nPoints = mOnlineTracker->size();
if (shouldInitFaceMesh)
{
shouldInitFaceMesh = false;
mFaceMesh.getBufferTexCoords0().clear();
auto imgSize = mOfflineTracker->getImageSize();
for (int i = 0; i < nPoints; i++)
{
vec3 point = mOfflineTracker->getImagePoint(i);
mFaceMesh.appendTexCoord({ point.x / imgSize.x, point.y / imgSize.y });
}
mOnlineTracker->addTriangleIndices(mFaceMesh);
}
mFaceMesh.getBufferPositions().clear();
for (int i = 0; i < nPoints; i++)
{
mFaceMesh.appendPosition(mOnlineTracker->getImagePoint(i));
}
if (VFX_VISIBLE && mOfflineFaceTex)
{
dispatchAsync(bind(&FaceOff::updateClone, this));
}
}
}
// *** MAIN START***
int main (int argc, const char * argv[]){
cmdl_opts opts;
get_opts( argc, argv, opts);
int nTimes=0, nT=0;
//*** EMITTED DATA OBJECTS ***
Emission cnaEmit, bafEmit, snvEmit;
if (opts.cna_fn != NULL) get_cna_data( &cnaEmit, opts, nTimes);
if (opts.baf_fn != NULL) get_baf_data( &bafEmit, opts, nTimes, nT);
if (opts.snv_fn != NULL) get_snv_data( &snvEmit, opts, nTimes, nT);
//*** ANNOUNCE ***
printf("\ncloneHD: probabilistic inference of sub-clonality using...\n\n");
if (cnaEmit.is_set){
printf("CNA data in %s: %i sites in %i chr across %i samples\n",
opts.cna_fn, cnaEmit.total_loci, cnaEmit.nSamples, nTimes);
}
if (bafEmit.is_set){
printf("BAF data in %s: %i sites in %i chr across %i samples\n",
opts.baf_fn, bafEmit.total_loci, bafEmit.nSamples, nTimes);
}
if (snvEmit.is_set){
printf("SNV data in %s: %i sites in %i chr across %i samples\n",
opts.snv_fn, snvEmit.total_loci, snvEmit.nSamples, nTimes);
}
cout<<endl;
// *** ALLOCATE CLONE ***
Clone myClone;
myClone.allocate( &cnaEmit, &bafEmit, &snvEmit, opts.chr_fn);
myClone.cna_pen_zero = opts.cna_pen_zero;//CNA penalty for zero total copies
myClone.cna_pen_diff = opts.cna_pen_diff;//CNA penalty for different c.n.
myClone.cna_pen_norm = opts.cna_pen_norm;//CNA penalty for non-normal c.n.
myClone.baf_pen_comp = opts.baf_pen_comp;//BAF penalty for complex chr status
myClone.snv_pen_high = opts.snv_pen_high;//SNV penalty for high SNV genotypes
myClone.snv_pen_mult = opts.snv_pen_mult;//SNV penalty for multiple hit SNVs
myClone.snv_fpr = opts.snv_fpr;//SNV false-positive rate
myClone.snv_fpf = opts.snv_fpf;//SNV frequency of false positives
myClone.bulk_fix = opts.bulk_fix;
myClone.cnaGrid = opts.cnaGrid;
myClone.bafGrid = opts.bafGrid;
myClone.snvGrid = opts.snvGrid;
myClone.bulkGrid = opts.bulkGrid;
myClone.learn_priors = (cnaEmit.is_set || snvEmit.connect || opts.avcn_fn != NULL) ? 0 : opts.learn_priors;
// *** GET MAX-TCN INFO ***
get_maxtcn_input( opts.maxtcn_fn, opts.maxtcn, &myClone);
// *** GET SNV BULK PRIOR ***
if ( snvEmit.is_set && opts.bulk_fn != NULL ){
printf("Using data in %s as SNV bulk prior...\n", opts.bulk_fn);
get_snv_bulk_prior( &myClone, opts);
}
//*** GET JUMP PROBABILITY TRACKS and COLLAPSE TO EVENTS***
get_jump_probability( &myClone, opts);
//...now all segments are fixed and mean_tcn/av_cn allocated.
if ( snvEmit.is_set && !cnaEmit.is_set ){//for SNV only
// *** GET TOTAL MEAN COPYNUMBER TRACK ***
if( opts.mntcn_fn != NULL ){
get_mean_tcn( opts.mntcn_fn, &myClone, &snvEmit);
}
// *** GET AVAILABLE COPYNUMBER TRACK ***
if ( opts.avcn_fn != NULL ){
get_avail_cn( opts.avcn_fn, &myClone, &snvEmit);
}
}
//*** GET READ DEPTH BIAS FIELD ***
if (cnaEmit.is_set && opts.bias_fn != NULL){
get_bias_field( &myClone, opts);
}
//*** PREPARE COARSE-GRAINED DATA ***
if (cnaEmit.is_set && (opts.cna_jumps_fn != NULL || opts.cna_jump == 0.0)){
cnaEmit.log_space = 1;
cnaEmit.coarse_grained = 1;
printf( "Collapsed CNA data to %5i segments based on potential jump events.\n",
cnaEmit.total_events);
cout<<"Precomputing for CNA..."<<flush;
myClone.get_cnaEmitLog();
cout<<"done."<<endl;
}
if (bafEmit.is_set && ( opts.cna_jumps_fn != NULL || opts.baf_jumps_fn != NULL || opts.baf_jump == 0.0)){
bafEmit.log_space = 1;
bafEmit.coarse_grained = 1;
printf("Collapsed BAF data to %5i segments based on potential jump events.\n", bafEmit.total_events);
cout<<"Precomputing for BAF..."<<flush;
myClone.get_bafEmitLog();
cout<<"done."<<endl;
}
if (snvEmit.is_set && opts.snv_jumps_fn != NULL){
snvEmit.log_space = 1;
snvEmit.coarse_grained = 1;
printf("Collapsed SNV data to %5i segments based on potential jump events.\n", snvEmit.total_events);
cout<<"Precomputing for SNV..."<<flush;
myClone.get_snvEmitLog();
cout<<"done."<<endl;
}
cout<<endl;
//exit(0);
// get purities...
if (opts.purity_fn != NULL){
get_purity( opts.purity_fn, myClone.min_purity);
}
// get user pre-defined clones
gsl_matrix * clones = NULL;
gsl_vector * mass = NULL;
if (opts.clones_fn != NULL) get_fixed_clones( clones, mass, opts.clones_fn, nTimes);
int bestn=0, rows=0;
if (mass != NULL && (int) mass->size > nTimes) rows = (int) mass->size;
if (clones != NULL && (int) clones->size1 > nTimes) rows = (int) clones->size1;
if (rows > nTimes){//print LLH's for predefined parameter values...
print_llh_for_set( clones, mass, &myClone, opts);
return(0);
}
else{
// ****** INFERENCE STARTS HERE ******
bestn = infer_clones( clones, mass, &myClone, opts);
printf("cloneHD in ");
if (cnaEmit.is_set && bafEmit.is_set && snvEmit.is_set) cout<<"cna-baf-snv ";
if (cnaEmit.is_set && bafEmit.is_set && !snvEmit.is_set) cout<<"cna-baf ";
if (cnaEmit.is_set && !bafEmit.is_set && snvEmit.is_set) cout<<"cna-snv ";
if (cnaEmit.is_set && !bafEmit.is_set && !snvEmit.is_set) cout<<"cna ";
if (!cnaEmit.is_set && !bafEmit.is_set && snvEmit.is_set) cout<<"snv ";
printf("mode found support for %i sub-clone(s) in the data.\n", bestn);
// ****** INFERENCE COMPLETED ********
}
print_all_results( &myClone, opts);
// all done...
return (0);
}
