/* Routine was patched by Hiroaki Morimoto, revised 2003/08/15. Rewritten by DPL 2004/05/16 to be more understandable. octaveCode returns octave adjustments in the order [absolute or =],[relative] */ void checkOctave(voice_index voice, Char *note) { Char code; code = octaveCode(note); if (code == '=') { setOctave(voice); removeOctaveCode(code, note); } if (octave(voice) == blank) return; code = octaveCode(note); if (isdigit(code)) { resetOctave(voice); return; } while (code == '+' || code == '-') { newOctave(voice, code); removeOctaveCode(code, note); code = octaveCode(note); } if (code != ' ') error3(voice, "You may have only one absolute octave assignment"); insertOctaveCode(octave(voice), note); checkRange(voice, note); resetOctave(voice); }
Pyramid::Pyramid(const Image &inputImage, const double inputSigma, const int octaveCount, const double levelCount) { Image levelImage = inputImage; double levelSigma = inputSigma; Image internalImage = levelImage.gaussFilter(sqrt(inputSigma * inputSigma - 0.5 * 0.5)); int octavsCount = log2f(std::min(inputImage.getHeight(),inputImage.getWidth())/50); for(int octaveNumber = 0; octaveNumber < octavsCount; octaveNumber++) { PyramidOctave octave(octaveNumber); levelSigma = inputSigma; if(octaveNumber > 0) { internalImage.copy(getOctave(octaveNumber-1).getLevel(levelCount-3).getImage()); internalImage.changeSize(qRound((double)internalImage.getWidth() / 2.0), qRound((double)internalImage.getHeight() / 2.0)); } for(int levelNumber = 0; levelNumber < levelCount + 2; levelNumber++) { if(levelNumber == 0 ) { PyramidLevel level(internalImage,levelSigma,levelNumber); octave.addLevel(level); } else { double tempSigma; levelSigma = inputSigma * pow(pow(2.0, 1.0 / (levelCount-1)), levelNumber); internalImage.copy(octave.getLevel(levelNumber-1).getImage()); tempSigma = sqrt(levelSigma * levelSigma - octave.getLevel(levelNumber-1).getSigma() * octave.getLevel(levelNumber-1).getSigma()); //printf("temp sigma %lf\n", tempSigma); PyramidLevel level(internalImage.gaussFilter(tempSigma),levelSigma,levelNumber); octave.addLevel(level); } } addOctave(octave); } }
//--------------------------------------------------------------------------------------- MidiPitch FPitch::to_midi_pitch() { MidiPitch nMidi = MidiPitch( (octave()+1) * 12 ); switch( int(to_diatonic_pitch()) % 7) { case 0: //si nMidi = nMidi + 11; break; case 1: //do //nothing to add. The value is ok break; case 2: //re nMidi = nMidi + 2; break; case 3: //mi nMidi = nMidi + 4; break; case 4: //fa nMidi = nMidi + 5; break; case 5: //sol nMidi = nMidi + 7; break; case 6: //la nMidi = nMidi + 9; break; } return nMidi + num_accidentals(); }
static void generate(void) { srand(time(NULL)); y=new2d(); z=new2d(); for(int a=1,t=2; t<=(SZ-1)/4; a*=2,t*=2) octave(a,t); del2d(y); save("land.dat"); del2d(z); }
//--------------------------------------------------------------------------------------- FPitch DiatonicPitch::to_FPitch(EKeySignature nKey) { // Get the accidentals implied by the key signature. // Each element of the array nAccidentals refers to one note: 0=Do, 1=Re, // 2=Mi, 3=Fa, ... , 6=Si and its value can be one of: 0=no accidental, // -1 = a flat, 1 = a sharp int nAccidentals[7]; KeyUtilities::get_accidentals_for_key(nKey, nAccidentals); int nStep = step(); return FPitch(nStep, octave(), nAccidentals[nStep]); }
//--------------------------------------------------------------------------------------- string DiatonicPitch::get_ldp_name() { // Returns the LDP note name (without accidentals). For example, // pitch 29 will return "c4". if (is_valid()) return m_sNoteName[step()] + m_sOctave[octave()]; else { LOMSE_LOG_ERROR("Operation on non-valid DiatonicPitch %d", m_dp); return "*"; //throw runtime_error("Operation on non-valid DiatonicPitch"); } }
//--------------------------------------------------------------------------------------- string FPitch::to_rel_ldp_name(EKeySignature nKey) { // The note LDP name, relative to received key signature, is returned. // For instace F4 sharp in C major will return "+f4" but in D major // will return "f4" as the accidental is implied by the key signature if (m_fp < 0) return "*"; // Get the accidentals implied by the key signature. // Each element of the array refers to one note: 0=Do, 1=Re, 2=Mi, 3=Fa, ... , 6=Si // and its value can be one of: 0=no accidental, -1 = a flat, 1 = a sharp int nAccidentals[7]; KeyUtilities::get_accidentals_for_key(nKey, nAccidentals); //compute note accidentals string sAnswer; int nAbsAcc = num_accidentals(); switch(nAbsAcc) { case -2: sAnswer ="--"; break; case -1: sAnswer ="-"; break; case 0: sAnswer =""; break; case 1: sAnswer ="+"; break; case 2: sAnswer ="x"; break; default: sAnswer = ""; } //change note accidentals to take key into account int nStep = step(); if (nAccidentals[nStep] != 0) { if (nAbsAcc == nAccidentals[nStep]) sAnswer = ""; //replace note accidental by key accidental else if (nAbsAcc == 0) sAnswer = "="; //force a natural //else //leave note accidentals } // add step letter and octave number sAnswer += m_sNoteName[nStep]; sAnswer += m_sOctave[octave()]; return sAnswer; }
Array< double, 2 > generateNoise( Vector2ui size, unsigned int seed, unsigned int octaves, double dropoff, bool tile ) { // Initialize the noise Array< double, 2 > noise( size.x, size.y ); for( unsigned int x = 0; x < size.x; ++x ) { for( unsigned int y = 0; y < size.y; ++y ) { noise[ x ][ y ] = 0; } } // Loop through the octaves double scaling_x = 1; double scaling_y = 1; double scale_factor_x = pow( static_cast< double >( size.x ), 1. / static_cast< double >( octaves - 1 ) ); double scale_factor_y = pow( static_cast< double >( size.y ), 1. / static_cast< double >( octaves - 1 ) ); for( unsigned int i = 0; i < octaves; ++i ) { Array< double, 2 > octave( size.x, size.y ); // Untiled octave if( !tile ) { octave = generateNoiseOctaveUntiled( size, seed, scaling_x, scaling_y ); } // Tiled octave else { octave = generateNoiseOctaveTiled( size, seed, scaling_x, scaling_y ); } // Combine octaves for( unsigned int x = 0; x < size.x; ++x ) { for( unsigned int y = 0; y < size.y; ++y ) { noise[ x ][ y ] = noise[ x ][ y ] * dropoff + octave[ x ][ y ]; } } // Update octave parameters scaling_x *= scale_factor_x; scaling_y *= scale_factor_y; } // Normalize the noise noise = normalizeNoise( noise ); return noise; }
//--------------------------------------------------------------------------------------- string FPitch::to_abs_ldp_name() { // The absolute LDP note name is returned // If note is invalid (more than two accidentals) returns empty string string sAnswer; switch(num_accidentals()) { case -2: sAnswer ="--"; break; case -1: sAnswer ="-"; break; case 0: sAnswer =""; break; case 1: sAnswer ="+"; break; case 2: sAnswer ="x"; break; default: return ""; } sAnswer += m_sNoteName[step()]; sAnswer += m_sOctave[octave()]; return sAnswer; }
float PianoKeyBoard::getBlackKeyOffset(int note) { float offset(0) ; float space(0) ; int whiteKeyCount(0) ; int blackKeyCount(0) ; int octaveNote = octave(note) ; for ( int i=0; i<octaveNote; ++i ) { if ( is_blackkey(i)) { ++blackKeyCount ; } else { ++whiteKeyCount ; } } if ( octaveNote < 5 ) { space = whiteKeyWidth_ - blackKeyWidth_ * 2 / 3 ; offset = space * whiteKeyCount + blackKeyWidth_ * blackKeyCount ; offset -= whiteKeyWidth_ * (whiteKeyCount - 1) ; } else { space = whiteKeyWidth_ - blackKeyWidth_ * 3 / 4 ; whiteKeyCount -= 3 ; blackKeyCount -= 2 ; offset = space * whiteKeyCount + blackKeyWidth_ * blackKeyCount ; offset -= whiteKeyWidth_ * (whiteKeyCount - 1) ; } if ( offset < 0 ) { assert(false) ; } return offset ; }
Array< double, 2 > generateNoiseOctaveUntiled( Vector2ui size, unsigned int seed, double scaling_x, double scaling_y ) { // Create the octave Array< double, 2 > octave( size.x, size.y ); for( unsigned int x = 0; x < size.x; ++x ) { for( unsigned int y = 0; y < size.y; ++y ) { // Recalculate the position double x_scaled = static_cast< double >( x ) / scaling_x; double y_scaled = static_cast< double >( y ) / scaling_y; // Calculate the sides unsigned int left = static_cast< unsigned int >( floor( x_scaled ) ); unsigned int right = static_cast< unsigned int >( ceil( x_scaled ) ); unsigned int top = static_cast< unsigned int >( floor( y_scaled ) ); unsigned int bottom = static_cast< unsigned int >( ceil( y_scaled ) ); // Calculate interpolation double x_interp = x_scaled - floor( x_scaled ); double y_interp = y_scaled - floor( y_scaled ); double t_x = x_interp * x_interp * ( 3 - 2 * x_interp ); double t_y = y_interp * y_interp * ( 3 - 2 * y_interp ); // Calculate the side values double topleft = noiseFunc2D( seed, left, top ); double topright = noiseFunc2D( seed, right, top ); double bottomleft = noiseFunc2D( seed, left, bottom ); double bottomright = noiseFunc2D( seed, right, bottom ); // Interpolate down to one value double left_value = ( 1 - t_y ) * topleft + t_y * bottomleft; double right_value = ( 1 - t_y ) * topright + t_y * bottomright; double value = ( 1 - t_x ) * left_value + t_x * right_value; octave[ x ][ y ] = value; } } return octave; }
static Fields* parseCascade(const FileNode &root, const float mins, const float maxs, const int totals, const int method) { static const char *const SC_STAGE_TYPE = "stageType"; static const char *const SC_BOOST = "BOOST"; static const char *const SC_FEATURE_TYPE = "featureType"; static const char *const SC_ICF = "ICF"; static const char *const SC_ORIG_W = "width"; static const char *const SC_ORIG_H = "height"; static const char *const SC_FEATURE_FORMAT = "featureFormat"; static const char *const SC_SHRINKAGE = "shrinkage"; static const char *const SC_OCTAVES = "octaves"; static const char *const SC_OCT_SCALE = "scale"; static const char *const SC_OCT_WEAKS = "weaks"; static const char *const SC_TREES = "trees"; static const char *const SC_WEAK_THRESHOLD = "treeThreshold"; static const char *const SC_FEATURES = "features"; static const char *const SC_INTERNAL = "internalNodes"; static const char *const SC_LEAF = "leafValues"; static const char *const SC_F_CHANNEL = "channel"; static const char *const SC_F_RECT = "rect"; // only Ada Boost supported std::string stageTypeStr = (std::string)root[SC_STAGE_TYPE]; CV_Assert(stageTypeStr == SC_BOOST); // only HOG-like integral channel features supported std::string featureTypeStr = (std::string)root[SC_FEATURE_TYPE]; CV_Assert(featureTypeStr == SC_ICF); int origWidth = (int)root[SC_ORIG_W]; int origHeight = (int)root[SC_ORIG_H]; std::string fformat = (std::string)root[SC_FEATURE_FORMAT]; bool useBoxes = (fformat == "BOX"); ushort shrinkage = cv::saturate_cast<ushort>((int)root[SC_SHRINKAGE]); FileNode fn = root[SC_OCTAVES]; if (fn.empty()) return 0; std::vector<device::Octave> voctaves; std::vector<float> vstages; std::vector<device::Node> vnodes; std::vector<float> vleaves; FileNodeIterator it = fn.begin(), it_end = fn.end(); for (ushort octIndex = 0; it != it_end; ++it, ++octIndex) { FileNode fns = *it; float scale = powf(2.f,saturate_cast<float>((int)fns[SC_OCT_SCALE])); bool isUPOctave = scale >= 1; ushort nweaks = saturate_cast<ushort>((int)fns[SC_OCT_WEAKS]); ushort2 size; size.x = cvRound(origWidth * scale); size.y = cvRound(origHeight * scale); device::Octave octave(octIndex, nweaks, shrinkage, size, scale); CV_Assert(octave.stages > 0); voctaves.push_back(octave); FileNode ffs = fns[SC_FEATURES]; if (ffs.empty()) return 0; std::vector<cv::Rect> feature_rects; std::vector<int> feature_channels; FileNodeIterator ftrs = ffs.begin(), ftrs_end = ffs.end(); int feature_offset = 0; for (; ftrs != ftrs_end; ++ftrs, ++feature_offset ) { cv::FileNode ftn = (*ftrs)[SC_F_RECT]; cv::FileNodeIterator r_it = ftn.begin(); int x = (int)*(r_it++); int y = (int)*(r_it++); int w = (int)*(r_it++); int h = (int)*(r_it++); if (useBoxes) { if (isUPOctave) { w -= x; h -= y; } } else { if (!isUPOctave) { w += x; h += y; } } feature_rects.push_back(cv::Rect(x, y, w, h)); feature_channels.push_back((int)(*ftrs)[SC_F_CHANNEL]); } fns = fns[SC_TREES]; if (fn.empty()) return false; // for each stage (~ decision tree with H = 2) FileNodeIterator st = fns.begin(), st_end = fns.end(); for (; st != st_end; ++st ) { FileNode octfn = *st; float threshold = (float)octfn[SC_WEAK_THRESHOLD]; vstages.push_back(threshold); FileNode intfns = octfn[SC_INTERNAL]; FileNodeIterator inIt = intfns.begin(), inIt_end = intfns.end(); for (; inIt != inIt_end;) { inIt +=2; int featureIdx = (int)(*(inIt++)); float orig_threshold = (float)(*(inIt++)); unsigned int th = saturate_cast<unsigned int>((int)orig_threshold); cv::Rect& r = feature_rects[featureIdx]; uchar4 rect; rect.x = saturate_cast<uchar>(r.x); rect.y = saturate_cast<uchar>(r.y); rect.z = saturate_cast<uchar>(r.width); rect.w = saturate_cast<uchar>(r.height); unsigned int channel = saturate_cast<unsigned int>(feature_channels[featureIdx]); vnodes.push_back(device::Node(rect, channel, th)); } intfns = octfn[SC_LEAF]; inIt = intfns.begin(), inIt_end = intfns.end(); for (; inIt != inIt_end; ++inIt) { vleaves.push_back((float)(*inIt)); } } } cv::Mat hoctaves(1, (int) (voctaves.size() * sizeof(device::Octave)), CV_8UC1, (uchar*)&(voctaves[0])); CV_Assert(!hoctaves.empty()); cv::Mat hstages(cv::Mat(vstages).reshape(1,1)); CV_Assert(!hstages.empty()); cv::Mat hnodes(1, (int) (vnodes.size() * sizeof(device::Node)), CV_8UC1, (uchar*)&(vnodes[0]) ); CV_Assert(!hnodes.empty()); cv::Mat hleaves(cv::Mat(vleaves).reshape(1,1)); CV_Assert(!hleaves.empty()); Fields* fields = new Fields(mins, maxs, totals, origWidth, origHeight, shrinkage, 0, hoctaves, hstages, hnodes, hleaves, method); fields->voctaves = voctaves; fields->createLevels(DEFAULT_FRAME_HEIGHT, DEFAULT_FRAME_WIDTH); return fields; }
bool Note::operator ==(const Note &other) const { return other.id() == id() and other.octave() == octave(); }
bool fill(const FileNode &root) { // cascade properties static const char *const SC_STAGE_TYPE = "stageType"; static const char *const SC_BOOST = "BOOST"; static const char *const SC_FEATURE_TYPE = "featureType"; static const char *const SC_ICF = "ICF"; static const char *const SC_ORIG_W = "width"; static const char *const SC_ORIG_H = "height"; static const char *const SC_OCTAVES = "octaves"; static const char *const SC_TREES = "trees"; static const char *const SC_FEATURES = "features"; static const char *const SC_INTERNAL = "internalNodes"; static const char *const SC_LEAF = "leafValues"; static const char *const SC_SHRINKAGE = "shrinkage"; static const char *const FEATURE_FORMAT = "featureFormat"; // only Ada Boost supported std::string stageTypeStr = (string)root[SC_STAGE_TYPE]; CV_Assert(stageTypeStr == SC_BOOST); std::string fformat = (string)root[FEATURE_FORMAT]; bool useBoxes = (fformat == "BOX"); // only HOG-like integral channel features supported string featureTypeStr = (string)root[SC_FEATURE_TYPE]; CV_Assert(featureTypeStr == SC_ICF); origObjWidth = (int)root[SC_ORIG_W]; origObjHeight = (int)root[SC_ORIG_H]; shrinkage = (int)root[SC_SHRINKAGE]; FileNode fn = root[SC_OCTAVES]; if (fn.empty()) return false; // for each octave FileNodeIterator it = fn.begin(), it_end = fn.end(); for (int octIndex = 0; it != it_end; ++it, ++octIndex) { FileNode fns = *it; Octave octave(octIndex, cv::Size(origObjWidth, origObjHeight), fns); CV_Assert(octave.weaks > 0); octaves.push_back(octave); FileNode ffs = fns[SC_FEATURES]; if (ffs.empty()) return false; fns = fns[SC_TREES]; if (fn.empty()) return false; FileNodeIterator st = fns.begin(), st_end = fns.end(); for (; st != st_end; ++st ) { weaks.push_back(Weak(*st)); fns = (*st)[SC_INTERNAL]; FileNodeIterator inIt = fns.begin(), inIt_end = fns.end(); for (; inIt != inIt_end;) nodes.push_back(Node(features.size(), inIt)); fns = (*st)[SC_LEAF]; inIt = fns.begin(), inIt_end = fns.end(); for (; inIt != inIt_end; ++inIt) leaves.push_back((float)(*inIt)); } st = ffs.begin(), st_end = ffs.end(); for (; st != st_end; ++st ) features.push_back(Feature(*st, useBoxes)); } return true; }
////--------------------------------------------------------------------------------------- DiatonicPitch FPitch::to_diatonic_pitch() { return DiatonicPitch(step(), octave()); }
Array< double, 2 > generateNoiseOctaveTiled( Vector2ui size, unsigned int seed, double scaling_x, double scaling_y ) { // Temporarily rescale Vector2ui full_size = size; size.x /= scaling_x; size.y /= scaling_y; // Create the octave Array< double, 2 > octave( size.x, size.y ); for( unsigned int x = 0; x < size.x; ++x ) { for( unsigned int y = 0; y < size.y; ++y ) { // Recalculate the position double x_norm = static_cast< double >( x ) / static_cast< double >( size.x ); double y_norm = static_cast< double >( y ) / static_cast< double >( size.y ); // Calculate the 4D parameters double nx = size.x * ( 1 + cos( x_norm * ( 2 * pi ) ) ) / 2; double ny = size.y * ( 1 + cos( y_norm * ( 2 * pi ) ) ) / 2; double nu = size.x * ( 1 + sin( x_norm * ( 2 * pi ) ) ) / 2; double nv = size.y * ( 1 + sin( y_norm * ( 2 * pi ) ) ) / 2; // Calculate the sides unsigned int x1 = static_cast< unsigned int >( floor( nx ) ); unsigned int x2 = static_cast< unsigned int >( ceil( nx ) ); unsigned int y1 = static_cast< unsigned int >( floor( ny ) ); unsigned int y2 = static_cast< unsigned int >( ceil( ny ) ); unsigned int u1 = static_cast< unsigned int >( floor( nu ) ); unsigned int u2 = static_cast< unsigned int >( ceil( nu ) ); unsigned int v1 = static_cast< unsigned int >( floor( nv ) ); unsigned int v2 = static_cast< unsigned int >( ceil( nv ) ); // Calculate the interpolations double x_interp = nx - floor( nx ); double y_interp = ny - floor( ny ); double u_interp = nu - floor( nu ); double v_interp = nv - floor( nv ); double t_x = x_interp * x_interp * ( 3 - 2 * x_interp ); double t_y = y_interp * y_interp * ( 3 - 2 * y_interp ); double t_u = u_interp * u_interp * ( 3 - 2 * u_interp ); double t_v = v_interp * v_interp * ( 3 - 2 * v_interp ); // Calculate the side values double val_1111 = noiseFunc4D( seed, x1, y1, u1, v1 ); double val_1112 = noiseFunc4D( seed, x1, y1, u1, v2 ); double val_1121 = noiseFunc4D( seed, x1, y1, u2, v1 ); double val_1122 = noiseFunc4D( seed, x1, y1, u2, v2 ); double val_1211 = noiseFunc4D( seed, x1, y2, u1, v1 ); double val_1212 = noiseFunc4D( seed, x1, y2, u1, v2 ); double val_1221 = noiseFunc4D( seed, x1, y2, u2, v1 ); double val_1222 = noiseFunc4D( seed, x1, y2, u2, v2 ); double val_2111 = noiseFunc4D( seed, x2, y1, u1, v1 ); double val_2112 = noiseFunc4D( seed, x2, y1, u1, v2 ); double val_2121 = noiseFunc4D( seed, x2, y1, u2, v1 ); double val_2122 = noiseFunc4D( seed, x2, y1, u2, v2 ); double val_2211 = noiseFunc4D( seed, x2, y2, u1, v1 ); double val_2212 = noiseFunc4D( seed, x2, y2, u1, v2 ); double val_2221 = noiseFunc4D( seed, x2, y2, u2, v1 ); double val_2222 = noiseFunc4D( seed, x2, y2, u2, v2 ); // Interpolation over v double val_111 = ( 1 - t_v ) * val_1111 + t_v * val_1112; double val_112 = ( 1 - t_v ) * val_1121 + t_v * val_1122; double val_121 = ( 1 - t_v ) * val_1211 + t_v * val_1212; double val_122 = ( 1 - t_v ) * val_1221 + t_v * val_1222; double val_211 = ( 1 - t_v ) * val_2111 + t_v * val_2112; double val_212 = ( 1 - t_v ) * val_2121 + t_v * val_2122; double val_221 = ( 1 - t_v ) * val_2211 + t_v * val_2212; double val_222 = ( 1 - t_v ) * val_2221 + t_v * val_2222; // Interpolation over u double val_11 = ( 1 - t_u ) * val_111 + t_u * val_112; double val_12 = ( 1 - t_u ) * val_121 + t_u * val_122; double val_21 = ( 1 - t_u ) * val_211 + t_u * val_212; double val_22 = ( 1 - t_u ) * val_221 + t_u * val_222; // Interpolation over y double val_1 = ( 1 - t_y ) * val_11 + t_y * val_12; double val_2 = ( 1 - t_y ) * val_21 + t_y * val_22; // Interpolation over x double value = ( 1 - t_x ) * val_1 + t_x * val_2; octave[ x ][ y ] = value; } } // Scale the octave Array< double, 2 > full_octave( full_size.x, full_size.y ); for( unsigned int x = 0; x < full_size.x; ++x ) { for( unsigned int y = 0; y < full_size.y; ++y ) { // Find the scaled down coordinates double x_scaled = static_cast< double >( x ) / scaling_x; double y_scaled = static_cast< double >( y ) / scaling_y; unsigned int left = static_cast< unsigned int >( floor( x_scaled ) ); unsigned int right = static_cast< unsigned int >( ceil( x_scaled ) ); unsigned int top = static_cast< unsigned int >( floor( y_scaled ) ); unsigned int bottom = static_cast< unsigned int >( ceil( y_scaled ) ); // Prevent bad coordinate access if( left >= size.x ) { left = 0; } if( right >= size.x ) { right = 0; } if( top >= size.y ) { top = 0; } if( bottom >= size.y ) { bottom = 0; } // Get the interpolation factors double x_interp = x_scaled - floor( x_scaled ); double y_interp = y_scaled - floor( y_scaled ); double t_x = x_interp * x_interp * ( 3. - 2. * x_interp ); double t_y = y_interp * y_interp * ( 3. - 2. * y_interp ); // Get the values double topleft_val = octave[ left ][ top ]; double topright_val = octave[ right ][ top ]; double bottomleft_val = octave[ left ][ bottom ]; double bottomright_val = octave[ right ][ bottom ]; // Interpolate down to one value double left_val = ( 1. - t_y ) * topleft_val + t_y * bottomleft_val; double right_val = ( 1. - t_y ) * topright_val + t_y * bottomright_val; double value = ( 1. - t_x ) * left_val + t_x * right_val; full_octave[ x ][ y ] = value; } } return full_octave; }
////--------------------------------------------------------------------------------------- FPitch FPitch::add_semitone(bool fUseSharps) { // This function adds one semitone and returns the resulting pitch. // Step and accidentals of new note are adjusted to use one accidental at // maximum, of the same type as requested by fUseSharps // step 0 0 1 1 2 3 3 4 4 5 5 6 // C C# D D# E F F# G G# A A# B // 3 4 9 10 15 20 21 26 27 32 33 38 // step 0 1 1 2 2 3 4 4 5 5 6 6 // C Db D Eb E F Gb G Ab A Bb B // 3 8 9 14 15 20 25 26 31 32 37 38 // extract components int nStep = step(); int nAcc = num_accidentals(); int nOctave = octave(); //Determine what type of accidentals to use for semitones: flats or sharps if (fUseSharps) { //Key signature is using sharps. //Only one accidental allowed and must be a sharp if (nAcc == 0) { //if no accidentals add one sharp or advance step, depending on current step if (nStep == 2 || nStep == 6) nStep++; else nAcc++; } else { if (nAcc < 0) //assume one flat: advance natural step nAcc = 0; else { //assume one sharp: advance to next natural step nStep++; nAcc=0; } } // Adjust octave if (nStep==7) { nStep = 0; nOctave++; } } else { //Key signature is using flats. //Only one accidental allowed and must be a flat if (nAcc == 0) { //if no accidentals advance step and, depending on new step, add one flat nStep++; if (nStep == 7) { nStep = 0; nOctave++; } else if (nStep != 3) nAcc--; } else { //assume one flat: remove accidentals to advance to the natural step nAcc=0; } } create(nStep, nOctave, nAcc); return *this; }
static void run (const gchar *name, gint nparams, const GimpParam *param, gint *nreturn_vals, GimpParam **return_vals) { static GimpParam values[1]; GimpPDBStatusType status = GIMP_PDB_SUCCESS; GimpDrawable *drawable; GimpRunMode run_mode; // create working directory char* home = getenv("HOME"); char dir[PATH_MAX + 1]; strcpy ( dir, home ); strcat ( dir, "/.gimp-octave" ); mkdir( dir, S_IRWXU ); run_mode = (GimpRunMode)param[0].data.d_int32; *return_vals = values; *nreturn_vals = 1; values[0].type = GIMP_PDB_STATUS; values[0].data.d_status = status; /* * Get drawable information... */ drawable = gimp_drawable_get (param[2].data.d_drawable); gimp_tile_cache_ntiles (2 * MAX (drawable->width / gimp_tile_width () + 1 , drawable->height / gimp_tile_height () + 1)); switch (run_mode) { case GIMP_RUN_INTERACTIVE: gimp_get_data (PLUG_IN_PROC, &octave_params); /* Reset default values show preview unmodified */ /* initialize pixel regions and buffer */ if (! octave_dialog (drawable)) return; break; case GIMP_RUN_NONINTERACTIVE: if (nparams != 6) { status = GIMP_PDB_CALLING_ERROR; } else { reset_default(); } break; case GIMP_RUN_WITH_LAST_VALS: gimp_get_data (PLUG_IN_PROC, &octave_params); break; default: break; } if (status == GIMP_PDB_SUCCESS) { drawable = gimp_drawable_get (param[2].data.d_drawable); /* here we go */ octave (drawable); gimp_displays_flush (); /* set data for next use of filter */ if (run_mode == GIMP_RUN_INTERACTIVE) gimp_set_data (PLUG_IN_PROC, &octave_params, sizeof (OctaveParams)); gimp_drawable_detach(drawable); values[0].data.d_status = status; } }