cml/libcw
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
fe74e41a0d
libcw/cwPerfMeas.cpp
kevin 9acb24e9e1 Apply licensing information to project.
2024-12-01 14:35:24 -05:00

1105 lines
35 KiB
C++
Raw Blame History

//| Copyright: (C) 2020-2024 Kevin Larke <contact AT larke DOT org>
//| License: GNU GPL version 3.0 or above. See the accompanying LICENSE file.
#include "cwCommon.h"
#include "cwLog.h"
#include "cwCommonImpl.h"
#include "cwTest.h"
#include "cwMem.h"
#include "cwText.h"
#include "cwFile.h"
#include "cwObject.h"
#include "cwMidi.h"
#include "cwDynRefTbl.h"
#include "cwScoreParse.h"
#include "cwSfScore.h"
#include "cwPerfMeas.h"
#include "cwVectOps.h"
/*
1. if a performed event is part of a set then mark the set complete when all events in it have been performed.
2. when a set is marked as complete it should be evaluated immediately.
3. once a complete set is evaluated it is never evaluated again (although incomplete sets may be evaluated again)
4. if a performed location is marked as a 'calc' location and all sets have been evaluated then the calc. is executed.
5. if a performed location is past the next-calc-loc then the calc is executed.
6. if a calc has already been executed and an event that is part of the calc is recieved then the
associated set is updated and the calc is executed again.
7. if a performed event occurs on a trigger location then the section update is executed.
8. if a performed event occurs on a trigger location that has already been executed then the section update is NOT
performed again.
*/
namespace cw
{
namespace perf_meas
{
struct calc_str;
typedef struct section_str
{
const struct section_str* prev_section; // section prior to this section
const sfscore::section_t* section; // score section this section_t represents
struct calc_str* calc; // calc record for this section
bool triggeredFl; // This section has already been triggered
} section_t;
typedef struct meas_info_str
{
unsigned missEvtN; // count of skipped events
unsigned missLocN; // count of missed locations
unsigned transposeLocN; // count of transposed locations
unsigned interpLocN; // count of interpolated locations
unsigned vN; // vN=locN for even,tempo vN=evtN for dyn
double* locSecV; // locSecV[vN]
unsigned* locSecNV; // locSecNV[vN] count of performed and interpolated notes (interpolated notes will have a False in the associated statusV[] location)
double* dSecV; // dSecV[vN]
bool* statusV; // statusV[vN] - true if this location was performed by at least one note
struct meas_info_str* link;
} meas_info_t;
struct loc_str;
typedef struct set_str
{
struct loc_str* loc; // end location for this set
const sfscore::set_t* set; // score set this set_t represents
meas_info_t* meas_info; //
unsigned lastPerfUpdateCnt;
double value; // The value associated with this set. DBL_MAX on initialization
struct calc_str* calc; // calc record to which this set belongs
struct set_str* alink; // perf_meas_t* links
struct set_str* slink; // loc_t.setL links
struct set_str* clink; // calc_t.setL links
} set_t;
// The 'calc_t' record hold pointers to all the sets assigned to a given section.
// The record is different from a section record because it has a location assignment
// prior to the section which it is represents. This allows all the sets for
// a given section to be evaluated prior to the section being triggered.
// The 'calc' record is assigned to the location of the last event in it's last set.
typedef struct calc_str
{
set_t* setL; // list of sets that this calc is applied to (links via set_t.clink)
section_t* section; // section where this calc is applied
double value[ kValCnt ]; // Aggregate var values for this section
} calc_t;
typedef struct loc_str
{
unsigned locId; // oloc location id and the index of this record into p->locA[]
section_t* section; // section that begins on this location
set_t* setL; // sets that end on this location (links via loc_t.slink)
calc_t* calc; // calc that can be completed on this location.
} loc_t;
typedef struct perf_meas_str
{
params_t params;
sfscore::handle_t scoreH;
loc_t* locA; // locA[locN]
unsigned locN; // length of locA[]
set_t* setL; // sets linked on alink
// Location index of the next section to be triggered.
unsigned last_section_loc_idx;
// Location of the next calc record to be evaluated.
unsigned next_section_loc_idx;
unsigned next_calc_loc_idx;
} perf_meas_t;
perf_meas_t* _handleToPtr( handle_t h )
{ return handleToPtr<handle_t,perf_meas_t>(h); }
inline unsigned _loc_id_to_index( perf_meas_t* p, unsigned locId )
{
if( locId >= p->locN )
return kInvalidIdx;
assert( locId == p->locA[locId].locId );
return locId;
}
void _destroy_meas_info_records( set_t* set )
{
meas_info_t* m = set->meas_info;
while( m!=nullptr )
{
meas_info_t* m0 = m->link;
mem::release(m->locSecV);
mem::release(m->locSecNV);
mem::release(m->dSecV);
mem::release(m->statusV);
mem::release(m);
m = m0;
}
}
rc_t _destroy( perf_meas_t* p )
{
rc_t rc = kOkRC;
for(unsigned i=0; i<p->locN; ++i)
{
set_t* s = p->locA[i].setL;
while(s!=nullptr)
{
set_t* s0 = s->slink;
_destroy_meas_info_records(s);
mem::release(s);
s = s0;
}
mem::release(p->locA[i].section);
mem::release(p->locA[i].calc);
}
mem::release(p->locA);
mem::release(p);
return rc;
}
set_t* _find_set( perf_meas_t* p, unsigned setId )
{
for(set_t* s=p->setL; s!=nullptr; s=s->alink)
if( s->set->id == setId )
return s;
cwLogError(kInvalidIdRC,"The setId '%i' is not valid.", setId );
return nullptr;
}
meas_info_t* _create_meas_info_record( set_t* set )
{
meas_info_t* m = mem::allocZ<meas_info_t>();
m->vN = set->set->varId==score_parse::kDynVarIdx ? set->set->evtCnt : set->set->locN;
m->locSecV = mem::allocZ<double>( m->vN );
m->locSecNV = mem::allocZ<unsigned>( m->vN );
m->dSecV = mem::allocZ<double>( m->vN );
m->statusV = mem::allocZ<bool>( m->vN );
if( set->meas_info == nullptr )
set->meas_info = m;
else
{
meas_info_t* m0 = set->meas_info;
while( m0->link != nullptr )
m0 = m0->link;
m0->link = m;
}
return m;
}
calc_t* _create_calc_record( perf_meas_t* p, sfscore::section_t* section )
{
rc_t rc = kOkRC;
calc_t* calc = mem::allocZ<calc_t>();
for(unsigned i=0; i<section->setCnt; ++i)
{
set_t* s;
if((s = _find_set(p,section->setArray[i]->id)) == nullptr )
{
rc = cwLogError(kInvalidIdRC,"Error forming section set list for the section '%s'.",cwStringNullGuard(section->label));
goto errLabel;
}
s->calc = calc;
s->clink = calc->setL;
calc->setL = s;
}
errLabel:
if( rc != kOkRC )
mem::release(calc);
return calc;
}
void _advance_next_calc_and_section_indexes( perf_meas_t* p, unsigned cur_section_idx )
{
p->last_section_loc_idx = cur_section_idx;
p->next_calc_loc_idx = kInvalidIdx;
p->next_section_loc_idx = kInvalidIdx;
// Set 'last_section_loc_idx' and 'next_calc_loc_idx'
for(unsigned i=cur_section_idx+1; i<p->locN && (p->next_section_loc_idx==kInvalidIdx || p->next_calc_loc_idx==kInvalidIdx); ++i)
{
if( p->next_section_loc_idx == kInvalidIdx && p->locA[i].section != nullptr )
p->next_section_loc_idx = i;
if( p->next_calc_loc_idx == kInvalidIdx && p->locA[i].calc != nullptr )
p->next_calc_loc_idx = i;
}
if( p->next_section_loc_idx == kInvalidIdx )
cwLogInfo("End-of-score reached on section index.");
else
if( p->next_calc_loc_idx == kInvalidIdx )
cwLogWarning("No 'next calc index' was found for the section at location:%i",p->next_section_loc_idx);
}
void _reset_loc( loc_t& loc)
{
if( loc.section != nullptr )
loc.section->triggeredFl = false;
if( loc.calc != nullptr )
{
for(set_t* set = loc.calc->setL; set!=nullptr; set=set->clink)
{
set->value = std::numeric_limits<double>::max();
set->lastPerfUpdateCnt = 0;
}
std::for_each(loc.calc->value,loc.calc->value+kValCnt,[](double& x){ x=std::numeric_limits<double>::max(); });
}
}
rc_t _reset( perf_meas_t* p, unsigned init_locId )
{
rc_t rc = kOkRC;
unsigned i = 0;
unsigned init_loc_idx = kInvalidIdx;
for(; i<p->locN; ++i)
{
if( p->locA[i].locId == init_locId )
init_loc_idx = i;
// reset all locations at and after the init. loc
if( init_loc_idx != kInvalidIdx )
_reset_loc(p->locA[i]);
}
if( init_loc_idx == kInvalidIdx )
{
rc = cwLogError(kInvalidIdRC,"The initial location id '%i' is not valid.",init_locId);
goto errLabel;
}
_advance_next_calc_and_section_indexes(p,init_loc_idx);
errLabel:
return rc;
}
double _calc_set_list_mean( const set_t* setL, unsigned varTypeId )
{
double sum = 0.0;
unsigned n = 0;
for(const set_t* s=setL; s!=nullptr; s=s->clink)
if( s->set->varId == varTypeId && s->value != std::numeric_limits<double>::max() )
{
sum += s->value;
n += 1;
}
return n>0 ? sum/n : 0.0;
}
void _eval_one_dynamic_set(perf_meas_t* p, set_t* set )
{
double sum = 0;
unsigned n = 0;
for(unsigned i=0; i<set->set->evtCnt; ++i)
{
const sfscore::event_t* e = set->set->evtArray[i];
if( e->perfFl )
{
sum += e->dynLevel>e->perfDynLevel ? e->dynLevel - e->perfDynLevel : e->perfDynLevel - e->dynLevel;
n += 1;
}
}
set->value = n==0 ? 0 : sum/n;
}
// Calc chord onset time as the avg. onset over of all notes in the chord.
rc_t _calc_loc_sec( set_t* pm_set )
{
rc_t rc = kOkRC;
const sfscore::set_t* set = pm_set->set;
meas_info_t* m = pm_set->meas_info;
m->missEvtN = 0;
assert( set->locN == m->vN );
vop::zero(m->locSecV, set->locN);
vop::zero(m->locSecNV, set->locN);
// Get the time for each location by taking the mean
// of all events on the same location.
unsigned li = 0;
unsigned curLocId = set->evtArray[0]->oLocId;
for(unsigned i=0; i<set->evtCnt; ++i)
{
if( !set->evtArray[i]->perfFl )
{
++m->missEvtN;
}
else
{
if( curLocId != set->evtArray[i]->oLocId )
{
li += 1;
curLocId = set->evtArray[i]->oLocId;
}
if( li >= set->locN )
{
rc = cwLogError(kAssertFailRC,"An invalid location id was encountered %i >= %i.",li,set->locN);
goto errLabel;
}
m->locSecV[ li] += set->evtArray[i]->perfSec;
m->locSecNV[li] += 1;
}
}
// Calc. mean.
for(unsigned i=0; i<set->locN; ++i)
if( m->locSecNV[i] > 0 )
m->locSecV[i] /= m->locSecNV[i];
errLabel:
return rc;
}
void _interpolate_time_of_missing_notes( perf_meas_t* p, set_t* pm_set, unsigned& bi_ref, unsigned& ei_ref )
{
bi_ref = kInvalidIdx;
ei_ref = kInvalidIdx;
const sfscore::set_t* set = pm_set->set;
meas_info_t* m = pm_set->meas_info;
unsigned missN = 0;
unsigned ei = kInvalidIdx;
unsigned bi = kInvalidIdx;
assert( set->locN == m->vN );
vop::fill(m->statusV, set->locN, false);
// for each location
for(unsigned i=0; i<set->locN; ++i)
{
// if this location was missed
if( m->locSecNV[i] == 0 )
{
missN += 1;
m->missLocN += 1;
continue;
}
// if this location was not in time order
if( ei != kInvalidIdx && (m->locSecV[i]-m->locSecV[ei])<0 )
{
missN += 1;
m->transposeLocN += 1;
continue;
}
// if there are unplayed notes between this note
// and the last played note at 'ei' then
// fill in the missing note times by splitting
// the gap time evenly - note that this will
// bias the evenness std to be lower than it
// should be.
if( missN > 0 && ei!=kInvalidIdx )
{
double dsec = (m->locSecV[i] - m->locSecV[ei])/(missN+1);
for(unsigned j=ei+1; j<i; ++j)
{
m->locSecV[j] = m->locSecV[j-1] + dsec;
m->interpLocN += 1;
}
}
if( bi == kInvalidIdx )
bi = i;
m->statusV[i] = true;
missN = 0;
ei = i; // ei=last valid location in m->locSecV[]
}
bi_ref = bi;
ei_ref = ei;
//vop::print( m->locSecV, set->locN, "%f ", "locSecV:" );
//vop::print( m->locSecNV, set->locN, "%i ", "locSecN:" );
//vop::print( m->statusV, set->locN, "%i ", "ok:");
}
rc_t _eval_one_even_set(perf_meas_t* p, set_t* pm_set )
{
rc_t rc = kOkRC;
const sfscore::set_t* set = pm_set->set;
unsigned bi = kInvalidIdx;
unsigned ei = kInvalidIdx;
meas_info_t* m = pm_set->meas_info;
assert( set->locN == m->vN );
if((rc = _calc_loc_sec(pm_set)) != kOkRC )
goto errLabel;
_interpolate_time_of_missing_notes(p, pm_set, bi, ei );
vop::zero(m->dSecV, set->locN);
// Calc the std. deviation of the note delta times
// of all notes [bi:ei]. Note that if the notes
// before bi/after ei were skipped then they are
// left out of the calculation. However skipped notes
// interal to the range bi:ei were interpolated
// as perfectly even.
if( (ei - bi)+1 > 2 )
{
// calc the delta time for each time in locV[]
unsigned stdN = 0;
for(unsigned i=bi+1; i<=ei; ++i)
m->dSecV[stdN++] = m->locSecV[i] - m->locSecV[i-1];
//printf("Even: skipped evt:%i skipped locs:%i interp:%i bi:%i ei:%i final N:%i\n",m->missEvtN,m->missLocN,m->interpLocN,bi,ei,stdN);
//vop::print( m->dSecV, stdN, "%f ", "std:" );
pm_set->value = vop::std(m->dSecV, stdN );
}
errLabel:
return rc;
}
rc_t _eval_one_tempo_set(perf_meas_t* p, set_t* pm_set )
{
rc_t rc = kOkRC;
const sfscore::set_t* set = pm_set->set;
meas_info_t* m = pm_set->meas_info;
unsigned bi = kInvalidIdx;
unsigned ei = kInvalidIdx;
assert( set->locN == m->vN );
if((rc = _calc_loc_sec(pm_set)) != kOkRC )
goto errLabel;
_interpolate_time_of_missing_notes(p, pm_set, bi, ei );
vop::zero(m->dSecV, set->locN);
if( (ei - bi)+1 > 2 )
{
// calc the delta time for each time in locV[]
unsigned dsecN = 0;
for(unsigned i=bi+1; i<=ei; ++i)
m->dSecV[dsecN++] = m->locSecV[i] - m->locSecV[i-1];
//printf("Tempo: skipped evt:%i skipped locs:%i interp:%i bi:%i ei:%i final N:%i\n",m->missEvtN,m->missLocN,m->interpLocN,bi,ei,dsecN);
//vop::print( m->dSecV, dsecN, "%f ", "dsecV:" );
double sec_per_beat = vop::mean(m->dSecV, dsecN );
double bpm = 60.0/sec_per_beat;
pm_set->value = bpm;
}
errLabel:
return rc;
}
void _aggregate_dynamic_meas_set_values( perf_meas_t* p, calc_t* calc )
{
calc->value[ kDynValIdx ] = _calc_set_list_mean( calc->setL, score_parse::kDynVarIdx );
}
void _aggregate_even_meas_set_values( perf_meas_t* p, calc_t* calc )
{
calc->value[ kEvenValIdx ] = _calc_set_list_mean( calc->setL, score_parse::kEvenVarIdx );
}
void _aggregate_tempo_meas_set_values( perf_meas_t* p, calc_t* calc )
{
calc->value[ kTempoValIdx ] = _calc_set_list_mean( calc->setL, score_parse::kTempoVarIdx );
}
void _aggregate_cost_meas_set_values( perf_meas_t* p, calc_t* calc )
{
if( calc->section->prev_section != nullptr )
{
unsigned beg_loc_idx = calc->section->prev_section->section->locPtr->index;
unsigned end_loc_idx = calc->section->section->locPtr->index;
const sfscore::loc_t* loc = loc_base(p->scoreH) + beg_loc_idx;
const sfscore::loc_t* loc_end = loc_base(p->scoreH) + end_loc_idx;
double sum = 0;
unsigned n = 0;
for(; loc<loc_end; ++loc)
for(unsigned i=0; i<loc->evtCnt; ++i)
if( loc->evtArray[i]->perfFl && loc->evtArray[i]->perfMatchCost != std::numeric_limits<double>::max() )
{
sum += loc->evtArray[i]->perfMatchCost;
n += 1;
}
calc->value[ kMatchCostValIdx ] = n==0 ? 0 : sum / n;
}
}
set_t* _use_slink(set_t* s){ return s->slink; }
set_t* _use_clink(set_t* s){ return s->clink; }
// Set 'force_fl' to true if the sets should be evaluated even if they are not complete.
void _eval_set_list( perf_meas_t* p, set_t* setL, set_t* (*link_func)(set_t*) )
{
// for each set at this location
for(set_t* s=setL; s!=nullptr; s=link_func(s))
{
// if this set has not been eval'd or has been updated with new perf. information since it was last eval'd
if( s->lastPerfUpdateCnt==0 || s->set->perfUpdateCnt > s->lastPerfUpdateCnt )
{
s->lastPerfUpdateCnt = s->set->perfUpdateCnt;
if( p->params.print_rt_events_fl )
cwLogInfo("Set %i eval.",s->set->id);
switch( s->set->varId )
{
case score_parse::kDynVarIdx:
_eval_one_dynamic_set(p,s);
break;
case score_parse::kEvenVarIdx:
_eval_one_even_set(p,s);
break;
case score_parse::kTempoVarIdx:
_eval_one_tempo_set(p,s);
break;
default:
cwLogError(kInvalidIdRC,"Unknown var type (%i) encountered while evaluating sets.",s->set->varId );
assert(0);
}
}
}
}
rc_t _update_sets( perf_meas_t* p, unsigned loc_idx )
{
rc_t rc = kOkRC;
if( p->locA[loc_idx].setL != nullptr && are_all_loc_set_events_performed( p->scoreH, loc_idx ) )
_eval_set_list(p,p->locA[loc_idx].setL,_use_slink);
return rc;
}
rc_t _update_calc( perf_meas_t* p, unsigned loc_idx )
{
rc_t rc = kOkRC;
// if the loc is past the next_calc_loc_idx or is equal to next_calc_loc_idx and all the set events have been performed for the location
if( p->next_calc_loc_idx != kInvalidIdx
&& (loc_idx > p->next_calc_loc_idx
|| (loc_idx == p->next_calc_loc_idx
&& are_all_loc_set_events_performed( p->scoreH, loc_idx ))))
{
if( p->params.print_rt_events_fl )
cwLogInfo("Calc: Loc:%i nci:%i",loc_idx,p->next_calc_loc_idx );
calc_t* calc = p->locA[ p->next_calc_loc_idx ].calc;
assert( calc != nullptr );
// eval any sets that have not already been evaluated - even if they are not complete
_eval_set_list(p,calc->setL, _use_clink);
// aggregate the measurements from each measurement type into a single scalar values.
_aggregate_dynamic_meas_set_values(p,calc);
_aggregate_even_meas_set_values(p,calc);
_aggregate_tempo_meas_set_values(p,calc);
_aggregate_cost_meas_set_values(p,calc);
}
return rc;
}
rc_t _update_section( perf_meas_t* p, unsigned loc_idx, result_t& resultRef )
{
rc_t rc = kOkRC;
// if next_section_loc_idx == kInvalidIdx then the end of the score has been encountered
// (or we are in an invalid state)
if( p->next_section_loc_idx == kInvalidIdx )
{
cwLogWarning("End-of-score or invalid state encountered (next_section_loc_idx==kInvalidIdx).");
goto errLabel;
}
// TODO: Should the following be a loop which iterates
// until p->next_section_loc_idx > loc_idx
if( p->next_section_loc_idx <= loc_idx )
{
assert( p->locA[p->next_section_loc_idx].section != nullptr );
section_t* section = p->locA[p->next_section_loc_idx].section;
if( section->triggeredFl == false )
{
assert( section->section != nullptr && section->section->locPtr != nullptr );
resultRef.loc = loc_idx;
resultRef.sectionLoc = section->section->locPtr->index;
resultRef.sectionLabel = section->section->label;
if( section->calc == nullptr )
cwLogWarning("No sets assigned to section %s",cwStringNullGuard(section->section->label));
else
{
resultRef.valueA = section->calc->value;
resultRef.valueN = kValCnt;
}
section->triggeredFl = true;
_advance_next_calc_and_section_indexes(p,p->next_section_loc_idx);
//cwLogInfo("Section %s triggered.",cwStringNullGuard(resultRef.sectionLabel));
}
}
errLabel:
return rc;
}
template< typename T >
rc_t _write_result_vector(file::handle_t fH, section_t* section, set_t* set, const char* opLabel, const char* fmt, const T* vect, unsigned locN)
{
rc_t rc;
if((rc = file::printf(fH,"%s,%i,%s,%s,%i,",
section->section->label,
set==nullptr ? -1 : set->set->id,
set==nullptr ? "" : score_parse::var_index_to_char(set->set->varId),
opLabel,
locN)) != kOkRC )
{
rc = cwLogError(rc,"Perf. measure vector header write failed.");
goto errLabel;
}
for(const T* v=vect; v<vect+locN; ++v)
if((rc = file::printf(fH,fmt,*v)) != kOkRC )
{
rc = cwLogError(rc,"Perf. measure vector write failed.");
goto errLabel;
}
if((rc = file::printf(fH,"\n")) != kOkRC )
{
rc = cwLogError(rc,"Perf. measure vector EOL failed.");
goto errLabel;
}
errLabel:
return rc;
}
double dbl_max_to_neg_one( double x )
{ return x==std::numeric_limits<double>::max() ? -1.0 : x; }
}
}
cw::rc_t cw::perf_meas::create( handle_t& hRef, sfscore::handle_t scoreH, const params_t& params )
{
rc_t rc;
if((rc = destroy(hRef)) != kOkRC )
return rc;
perf_meas_t* p = mem::allocZ<perf_meas_t>();
const sfscore::loc_t* locA = sfscore::loc_base(scoreH);
const section_t* prev_section = nullptr;
p->scoreH = scoreH;
p->params = params;
p->locN = loc_count(scoreH);
p->locA = mem::allocZ<loc_t>(p->locN);
p->next_section_loc_idx = kInvalidIdx;
p->next_calc_loc_idx = kInvalidIdx;
// for each score location
for(unsigned i=0; i<p->locN; ++i)
{
// the index of the record into p->locA[]
// is the same as the locId of the associated location
assert( i == locA[i].index );
p->locA[i].locId = locA[i].index;
// if this location is the end of a set (or sets) ...
for(sfscore::set_t* s=locA[i].setList; s!=nullptr; s=s->llink)
{
// ... link the sets onto this location record
set_t* set = mem::allocZ<set_t>();
set->loc = p->locA + i;
set->set = s;
set->slink = p->locA[i].setL;
p->locA[i].setL = set;
set->alink = p->setL;
p->setL = set;
_create_meas_info_record(set);
}
// if this location is the start of a new section
if( locA[i].begSectPtr != nullptr )
{
p->locA[i].section = mem::allocZ<section_t>();
p->locA[i].section->prev_section = prev_section;
p->locA[i].section->section = locA[i].begSectPtr;
prev_section = p->locA[i].section;
if(locA[i].begSectPtr->measLocPtr != nullptr )
{
// get the loc of the last event in the last set that applies to this section
// (this is where the sets that supply this section will be evaluated)
unsigned calc_loc_idx = locA[i].begSectPtr->measLocPtr->index;
assert( calc_loc_idx < p->locN);
// verify that the 'calc' location is <= the section location
if( calc_loc_idx > locA[i].index )
{
rc = cwLogError(kInvalidStateRC,"The last loc %i of the last set in section '%s' is after the section start at loc: %i.", calc_loc_idx, cwStringNullGuard(locA[i].begSectPtr->label),i);
goto errLabel;
}
// verify that that the calc location is available
if( p->locA[ calc_loc_idx ].calc != nullptr )
{
rc = cwLogError(kInvalidStateRC,"A given location (%i) may only have one 'calc' record.",calc_loc_idx);
goto errLabel;
}
// create the 'calc' record preceding this section
if(( p->locA[ calc_loc_idx ].calc = _create_calc_record( p, locA[i].begSectPtr )) == nullptr )
{
rc = cwLogError(kInvalidIdRC,"The 'calc' object create failed at location %i",calc_loc_idx);
goto errLabel;
}
// set the calc.section pointer and the section.calc pointer
p->locA[ calc_loc_idx ].calc->section = p->locA[i].section;
p->locA[i].section->calc = p->locA[ calc_loc_idx ].calc;
}
}
}
if((rc = _reset(p,0)) != kOkRC )
{
rc = cwLogError(rc,"Perf. meas initial reset failed.");
goto errLabel;
}
hRef.set(p);
errLabel:
if(rc != kOkRC )
_destroy(p);
return rc;
}
cw::rc_t cw::perf_meas::destroy( handle_t& hRef )
{
rc_t rc = kOkRC;
if( !hRef.isValid() )
return rc;
perf_meas_t* p = _handleToPtr(hRef);
if((rc = _destroy(p)) != kOkRC )
{
rc = cwLogError(rc,"Destroy failed.");
return rc;
}
hRef.clear();
return rc;
}
cw::rc_t cw::perf_meas::reset( handle_t h, unsigned init_locId )
{
perf_meas_t* p = _handleToPtr(h);
return _reset(p,init_locId);
}
cw::rc_t cw::perf_meas::exec( handle_t h, const sfscore::event_t* event, result_t& resultRef )
{
rc_t rc = kOkRC;
perf_meas_t* p = _handleToPtr(h);
unsigned loc_idx;
resultRef = {};
resultRef.loc = kInvalidIdx;
resultRef.sectionLoc = kInvalidIdx;
// get the index of the location record associated with this event
if((loc_idx = _loc_id_to_index(p,event->oLocId )) == kInvalidIdx )
{
cwLogError(kInvalidIdRC,"The event loc %i is not valid.",event->oLocId);
goto errLabel;
}
// if this event is prior to the last triggered section then ignore it
if( p->last_section_loc_idx != kInvalidIdx && loc_idx < p->last_section_loc_idx )
{
cwLogWarning("Backtrack before last triggered section loc:%i < last section:%i.",loc_idx,p->last_section_loc_idx);
goto errLabel;
}
// if this location is attached to a set then eval the set if it is complete
if((rc = _update_sets(p,loc_idx)) != kOkRC )
{
rc = cwLogError(rc,"Set update failed.");
goto errLabel;
}
// if this location is at or after 'next_calc_loc_idx' then evaluate the calc record
if((rc = _update_calc(p,loc_idx)) != kOkRC )
{
rc = cwLogError(rc,"Calc. update failed.");
goto errLabel;
}
// if this location is at or after the next section then update the section from the calc.
if((rc = _update_section(p,loc_idx,resultRef)) != kOkRC )
{
rc = cwLogError(rc,"Section update failed.");
goto errLabel;
}
errLabel:
if( rc != kOkRC )
rc = cwLogError(rc,"Perf-meas exec failed.");
return rc;
}
void cw::perf_meas::report( handle_t h )
{
perf_meas_t* p = _handleToPtr(h);
for(unsigned i=0; i<p->locN; ++i)
{
loc_t* loc = p->locA + i;
bool fl = loc->section || loc->setL || loc->calc;
if( fl )
printf("%i : ",loc->locId );
if( loc->section )
{
printf("section:%s ", loc->section->section->label );
}
set_t* s;
if( loc->setL != nullptr )
{
printf("set: ");
for(s=loc->setL; s!=nullptr; s=s->slink)
printf("%i ", s->set->id);
}
if( loc->calc != nullptr )
{
printf("calc: ");
for(s=loc->calc->setL; s!=nullptr; s=s->clink)
printf("%i ", s->set->id);
}
if(fl)
printf("\n");
}
}
cw::rc_t cw::perf_meas::write_result_json( handle_t h,
const char* player_name,
const char* perf_date,
unsigned perf_take_numb,
const char* out_fname )
{
rc_t rc = kOkRC;
perf_meas_t* p = _handleToPtr(h);
object_t* root = newDictObject();
object_t* sectionL = root->insert_pair("sectionL",newListObject());
for(loc_t* loc=p->locA; loc<p->locA+p->locN; ++loc)
if( loc->section != nullptr && loc->section->calc != nullptr && loc->section->triggeredFl )
{
object_t* sect = newDictObject(sectionL);
const double* valueV = loc->section->calc->value;
object_t* setL = newListObject();
sect->putv("label",loc->section->section->label,
"player_name",player_name,
"perf_date",perf_date,
"perf_take_numb",perf_take_numb,
"locId",loc->locId,
"dyn",dbl_max_to_neg_one(valueV[kDynValIdx]),
"even",dbl_max_to_neg_one(valueV[kEvenValIdx]),
"tempo",dbl_max_to_neg_one(valueV[kTempoValIdx]),
"cost",dbl_max_to_neg_one(valueV[kMatchCostValIdx]),
"setL",setL);
for(set_t* set=loc->section->calc->setL; set!=nullptr; set=set->clink)
{
object_t* set_o = newDictObject(setL);
set_o->putv("type",score_parse::var_index_to_char(set->set->varId),
"setId",set->set->id,
"locId",set->loc->locId,
"value",dbl_max_to_neg_one(set->value),
"missEvtN",set->meas_info->missEvtN,
"missLocN",set->meas_info->missLocN,
"transposeLocN",set->meas_info->transposeLocN,
"interpLocN",set->meas_info->interpLocN);
set_o->put_numeric_list("locSecV", set->meas_info->locSecV, set->meas_info->vN );
set_o->put_numeric_list("locSecNV", set->meas_info->locSecNV, set->meas_info->vN );
set_o->put_numeric_list("dSecV", set->meas_info->dSecV, set->meas_info->vN );
set_o->put_numeric_list("statusV", set->meas_info->statusV, set->meas_info->vN );
}
}
if((rc = objectToFile(out_fname,root)) != kOkRC )
{
rc = cwLogError(rc,"Perf. measurement JSON file write failed.");
goto errLabel;
}
errLabel:
root->free();
return rc;
}
cw::rc_t cw::perf_meas::write_result_csv( handle_t h, const char* out_fname )
{
rc_t rc = kOkRC;
perf_meas_t* p = _handleToPtr(h);
file::handle_t fH;
if((rc = file::open(fH,out_fname, file::kWriteFl)) != kOkRC )
{
rc = cwLogError(rc,"Perf. measure result file create failed on '%s'.",cwStringNullGuard(out_fname));
goto errLabel;
}
if((rc = file::printf(fH,"section,set,type,op,value,missEvtN,missLocN,transposeLocN,interpLocN\n")) != kOkRC )
{
rc = cwLogError(rc,"Perf. measure title write failed.");
goto errLabel;
}
for(loc_t* loc=p->locA; loc<p->locA+p->locN; ++loc)
if( loc->section != nullptr && loc->section->calc != nullptr )
{
if((rc = _write_result_vector(fH,loc->section,nullptr,"section","%f,",loc->section->calc->value,kValCnt)) != kOkRC )
{
rc = cwLogError(rc,"Perf. measure file write result section header failed.");
goto errLabel;
}
for(set_t* set=loc->section->calc->setL; set!=nullptr; set=set->clink)
{
if((rc = file::printf(fH,"%s,%i,%s,summary,%f,%i,%i,%i,%i\n",
loc->section->section->label,
set->set->id,
score_parse::var_index_to_char(set->set->varId),
set->value != std::numeric_limits<double>::max() ? set->value : 0,
set->meas_info->missEvtN,
set->meas_info->missLocN,
set->meas_info->transposeLocN,
set->meas_info->interpLocN)) != kOkRC )
{
rc = cwLogError(rc,"Perf. measure file write result failed.");
goto errLabel;
}
if((rc = _write_result_vector(fH,loc->section,set,"locSecV","%f,",set->meas_info->locSecV,set->set->locN)) != kOkRC )
{
rc = cwLogError(rc,"Perf.measure locSecV[] write result failed.");
goto errLabel;
}
if((rc = _write_result_vector(fH,loc->section,set,"locSecNV","%i,",set->meas_info->locSecNV,set->set->locN)) != kOkRC )
{
rc = cwLogError(rc,"Perf.measure locSecNV[] write result failed.");
goto errLabel;
}
if((rc = _write_result_vector(fH,loc->section,set,"dSecV","%f,", set->meas_info->dSecV,set->set->locN)) != kOkRC )
{
rc = cwLogError(rc,"Perf.measure dSecV[] write result failed.");
goto errLabel;
}
if((rc = _write_result_vector(fH,loc->section,set,"statusV","%i,",set->meas_info->statusV,set->set->locN)) != kOkRC )
{
rc = cwLogError(rc,"Perf.measure status[] write result failed.");
goto errLabel;
}
}
}
if((rc = file::close(fH)) != kOkRC )
{
rc = cwLogError(rc,"Perf. meas. file close failed.");
goto errLabel;
}
errLabel:
return rc;
}
Reference in New Issue View Git Blame Copy Permalink