void testBaumwelch(int seqlen){
int error;
ghmm_dmodel * mo_gen = NULL;
ghmm_dmodel * mo_time = NULL;
ghmm_dmodel * mo_mem = NULL;
ghmm_dseq * my_output = NULL;
if (!(mo_gen = malloc (sizeof (ghmm_dmodel))))
{printf ("malloc failed in line %d", __LINE__); exit(1);}
if (!(mo_time = malloc (sizeof (ghmm_dmodel))))
{printf ("malloc failed in line %d", __LINE__); exit(1);}
if (!(mo_mem = malloc (sizeof (ghmm_dmodel))))
{printf ("malloc failed in line %d", __LINE__); exit(1);}
/* generate a model with variable number of states*/
generateModel(mo_gen, 7, 92304);
generateModel(mo_time, 5, 1704);
generateModel(mo_mem, 5, 1704);
/*generate a random sequence*/
my_output = ghmm_dmodel_label_generate_sequences(mo_gen, 0, seqlen, NR_SEQUENCES, seqlen);
/* ghmm_dmodel_add_noise(mo_time, .499, 0); */
/* randomize the second */
/* ghmm_dmodel_add_noise(mo_mem, .499, 0); */
ghmm_dmodel_print(stdout, mo_time);
ghmm_dmodel_print(stdout, mo_mem);
printf("Distance between the two models: %g\n\n", ghmm_dmodel_distance(mo_time, mo_mem));
/* shifting both models in diffrent directions */
/* train the first */
/*ghmm_dmodel_label_baum_welch(mo_time, my_output);*/
error = ghmm_dmodel_baum_welch(mo_time, my_output);
/* train the second and hope they are equal */
error = ghmm_dmodel_baum_welch(mo_mem, my_output);
ghmm_dmodel_print(stdout, mo_time);
ghmm_dmodel_print(stdout, mo_mem);
printf("Distance between the two trained models: %g\n", ghmm_dmodel_distance(mo_time, mo_mem));
printf("Log-Likelyhood generating: %g\n", ghmm_dmodel_likelihood (mo_gen, my_output));
printf("Log-Likelyhood fb-Baum-Welch: %g\n", ghmm_dmodel_likelihood (mo_time, my_output));
printf("Log-Likelyhood me-Baum-Welch: %g\n", ghmm_dmodel_likelihood (mo_mem, my_output));
/* freeing memory */
ghmm_dmodel_free(&mo_gen);
ghmm_dmodel_free(&mo_time);
ghmm_dmodel_free(&mo_mem);
ghmm_dseq_free(&my_output);
}
void PluginGame5GenerateSituationDialog::onClickOk()
{
rdo::gui::model::Model* pModel = getCurrentModel();
generateModel();
pModel->runModel();
done(Accepted);
}
void milxQtDiffusionTensorModel::harmonics(QString ordersString)
{
bool ok = false;
if(ordersString.isEmpty())
{
ordersString = QInputDialog::getText(this, tr("Enter order magnitudes of harmonics separated by spaces"),
tr("Orders: "), QLineEdit::Normal,
"1 0 0 0 1 1 1 1 1", &ok);
}
if (!ok || ordersString.isEmpty())
return;
QStringList orders = ordersString.split(" ");
std::vector<double> sHarmonicCoefficients;
for(int i = 0; i < orders.size(); i++)
sHarmonicCoefficients.push_back(orders[i].toDouble());
int n_coefs = sHarmonicCoefficients.size();
int l_max = milxQtDiffusionTensorModel::LforN( n_coefs );
vtkSmartPointer<vtkSphereSource> sphereSource = vtkSmartPointer<vtkSphereSource>::New();
sphereSource->SetThetaResolution( 64 );
sphereSource->SetPhiResolution( 64 );
sphereSource->SetRadius( 1.0 );
sphereSource->Update();
vtkSmartPointer<vtkPolyData> glyph = sphereSource->GetOutput();
///For every point in sphere mesh
double m_x = 0, m_y = 0, m_z = 0;
for(int i = 0; i < glyph->GetNumberOfPoints(); i++)
{
double point_sphere[3];
glyph->GetPoint(i, point_sphere);
double x_s = point_sphere[0];
double y_s = point_sphere[1];
double z_s = point_sphere[2];
double x_g, y_g, z_g;
///Compute spherical harmonic amplitude
double amplitude = computeAmplitude( sHarmonicCoefficients, x_s, y_s, z_s, l_max );
if(amplitude < 0)
amplitude = 0;
///use this to displace sphere points accordingly
x_g = x_s * amplitude + m_x;
y_g = y_s * amplitude + m_y;
z_g = z_s * amplitude + m_z;
glyph->GetPoints()->SetPoint(i, x_g, y_g, z_g);
}
model.SetInput(glyph);
model.GenerateNormals(true);
generateModel();
milxQtRenderWindow::reset();
}
QTGTrackListModel::QTGTrackListModel(QTGSequenceModel* sequenceModel, tg::DataFile* dataFile, QObject *parent)
: QAbstractListModel(parent)
, m_sequenceModel(sequenceModel)
, m_dataFile(dataFile)
{
m_roles[Track] = "track";
generateModel();
}
void Item::setup(){
program.build("item");
program.getUniformLocation("sprites");
program.getUniformLocation("sprite");
program.getUniformLocation("position");
//lastTime = glfwGetTime();
generateModel();
}
Model* LoadModel(char* name)
{
Model* model = 0;
Mesh* mesh = LoadOBJ(name);
if (!mesh)
return 0;
DecomposeToTriangles(mesh);
generateNormals(mesh);
model = generateModel(mesh);
return model;
}
int Application::main(int argc,char *argv[])
{
// Process command line
BOOM::CommandLine cmd(argc,argv,"");
if(cmd.numArgs()!=5)
throw BOOM::String(
"\ntrain-signal-peptide-model <*.gff> <*.fasta> <outfile>\n\
<start-codon.model> <field-lengths>\n\
where <*.gff> contains items with the type \"signal_peptide\"\n\
<window-len> = length in #codons\n\
<start-codon.model> is a WMM\n\
<field-lengths> is a comma-separate list of lengths (in acids)\n\
\n");
BOOM::String gffFile=cmd.arg(0);
BOOM::String fastaFile=cmd.arg(1);
BOOM::String outfile=cmd.arg(2);
BOOM::String startCodonModelFile=cmd.arg(3);
BOOM::String lengths=cmd.arg(4);
initFields(lengths);
// Load signal peptide coordinates from GFF
cerr<<"Loading signal peptide coordinates..."<<endl;
loadSignalPeptideCoords(gffFile,fastaFile);
// Load transcript coordinates from GFF
cerr<<"Loading transcript coordinates..."<<endl;
loadTranscriptCoords(gffFile);
// Study codon usage in transcripts
cerr<<"Collecting codon usage statistics from transcripts..."<<endl;
studyCodonUsage(fastaFile);
// Study amino acid usage in signal peptides
cerr<<"Collecting amino acid frequencies from signal peptides..."<<endl;
studyAminoUsage();
// Generate output
cerr<<"Finishing model and writing output..."<<endl;
generateModel(outfile,startCodonModelFile);
return 0;
}
void milxQtDiffusionTensorModel::colourByDirection()
{
vtkSmartPointer<vtkPolyData> currentMesh = model.Result();
typedef double projectionType;
///Determine colours based on axes directions
vtkSmartPointer<vtkUnsignedCharArray> scalars = vtkSmartPointer<vtkUnsignedCharArray>::New();
scalars->SetNumberOfComponents(3);
scalars->SetNumberOfTuples(currentMesh->GetNumberOfPoints());
scalars->SetName("Fibre Colours");
scalars->FillComponent(0, 0);
scalars->FillComponent(1, 0);
scalars->FillComponent(2, 0);
vtkSmartPointer<vtkFloatArray> projections = vtkSmartPointer<vtkFloatArray>::New();
projections->SetNumberOfComponents(3);
projections->SetNumberOfTuples(currentMesh->GetNumberOfPoints());
projections->SetName("Fibre Projections");
projections->FillComponent(0, 0.0);
projections->FillComponent(1, 0.0);
projections->FillComponent(2, 0.0);
emit working(-1);
if(currentMesh->GetNumberOfLines() == 0)
{
printInfo("No lines in model. Computing colours for mesh.");
///Use the dot product in each axis
for(size_t j = 0; j < 3; j ++)
{
projectionType axis[3] = {0.0, 0.0, 0.0};
axis[j] = 1.0;
cout << "Computing toward axis " << j << endl;
///Colour based on each of the gradient values in that direction
for(vtkIdType k = 0; k < currentMesh->GetNumberOfPoints(); k ++)
{
coordinate currentProjection(projections->GetTuple3(k)), position(currentMesh->GetPoint(k));
projectionType projection = vtkMath::Dot(axis, position.data_block()); //project to axis being done,
currentProjection[j] = projection; //projection in each direction
projections->SetTuple3(k, currentProjection[0], currentProjection[1], currentProjection[2]);
}
}
///Colour based on each of the gradient values in that direction
for(vtkIdType k = 0; k < currentMesh->GetNumberOfPoints(); k ++)
{
coordinate currentProjection(projections->GetTuple3(k));
coordinate currentProjSquared = element_product(currentProjection, currentProjection);
projectionType maxProjection = currentProjSquared.max_value();
currentProjSquared /= maxProjection;
unsigned char colourOfPoint[3] = {0, 0, 0};
colourOfPoint[0] = static_cast<unsigned char>( currentProjSquared[0]*255.0 );
colourOfPoint[1] = static_cast<unsigned char>( currentProjSquared[1]*255.0 );
colourOfPoint[2] = static_cast<unsigned char>( currentProjSquared[2]*255.0 );
scalars->SetTupleValue(k, colourOfPoint);
}
currentMesh->GetPointData()->SetVectors(projections);
currentMesh->GetPointData()->SetScalars(scalars);
}
else
{
printInfo("Re-colouring lines by axes directions");
//Ensure lines done properly so can colour appropriately
currentMesh->GetLines()->InitTraversal();
vtkSmartPointer<vtkPoints> points = vtkSmartPointer<vtkPoints>::New();
vtkSmartPointer<vtkIdList> idList = vtkSmartPointer<vtkIdList>::New();
std::vector<vtkIdType> trackLengths;
for(vtkIdType j = 0; j < currentMesh->GetNumberOfLines(); j ++)
{
currentMesh->GetLines()->GetNextCell(idList);
trackLengths.push_back(idList->GetNumberOfIds());
for(vtkIdType pointId = 0; pointId < idList->GetNumberOfIds(); pointId ++)
{
// std::cout << idList->GetId(pointId) << " ";
double position[3];
currentMesh->GetPoint(idList->GetId(pointId), position);
points->InsertNextPoint(position);
}
}
//Re-stitch lines together
vtkIdType step = 0;
vtkSmartPointer<vtkCellArray> lines = vtkSmartPointer<vtkCellArray>::New();
for(size_t j = 0; j < trackLengths.size(); j ++)
{
for(vtkIdType k = step; k < trackLengths[j]-1; k ++)
{
vtkSmartPointer<vtkLine> line = vtkSmartPointer<vtkLine>::New();
line->GetPointIds()->SetId(0, k);
line->GetPointIds()->SetId(1, k+1);
lines->InsertNextCell(line);
}
qDebug() << trackLengths[j] << endl;
step += trackLengths[j];
}
vtkSmartPointer<vtkPolyData> linesPolyData = vtkSmartPointer<vtkPolyData>::New();
//Add the points to the dataset
linesPolyData->SetPoints(points);
//Add the lines to the dataset
linesPolyData->SetLines(lines);
linesPolyData->Modified();
model.SetInput(linesPolyData);
}
emit done(-1);
generateModel();
}
void testBaumwelch(){
int i, error, tl,z,z1,z2;
double log_p,first_prob1,first_prob2, first_prob;
double *proba;
int *path;
int* real_path;
int *path1;
int* real_path1;
int *path2;
int* real_path2;
model *mo = NULL;
sequence_t *my_output, *your_output;
int seqlen = 1000;
tl = 150;
mo = malloc(sizeof(model));
if (mo==NULL) {fprintf(stderr,"Null Pointer in malloc(model).\n");}
real_path = malloc(seqlen*sizeof(double));
if(!real_path){ printf("real_path hat kein platz gekriegt\n");}
real_path1 = malloc(seqlen*sizeof(double));
if(!real_path1){ printf("real_path hat kein platz gekriegt\n");}
real_path2 = malloc(seqlen*sizeof(double));
if(!real_path2){ printf("real_path hat kein platz gekriegt\n");}
/* generate a model with variable number of states*/
generateModel(mo, 5);
/*generate a random sequence*/
my_output = model_label_generate_sequences(mo, 0, seqlen, 10, seqlen);
for (i=0; i<seqlen; i++){
printf("%d", my_output->state_labels[0][i]);
}
printf("\n");
/*viterbi*/
path = viterbi(mo, my_output->seq[0], my_output->seq_len[0], &first_prob);
path1 = viterbi(mo, my_output->seq[1], my_output->seq_len[1], &first_prob1);
path2 = viterbi(mo, my_output->seq[2], my_output->seq_len[2], &first_prob2);
printf("\n viterbi-path\n");
z=0;
z1=0;
z2=0;
for (i=0; i<my_output->seq_len[0]; i++){
if (path1[i] != -1) {
real_path1[z1]=path1[i];
z1++;
printf("%d", path1[i]);
}
else printf("hallo");
if (path2[i] != -1) {
real_path2[z2]=path2[i];
z2++;
printf("%d", path2[i]);
}
else printf("hallo");
if (path[i] != -1) {
real_path[z]=path[i];
z++;
printf("%d", path[i]);
}
}
printf("\n");
printf("log-prob: %g\n",first_prob);
my_output->state_labels[0]=real_path;
my_output->state_labels[1]=real_path1;
my_output->state_labels[2]=real_path2;
for (i=0;i<seqlen;i++)
printf("realpath[%i]=%i",i,real_path[i]);
proba = malloc(sizeof(double)*tl);
printf("No of Sequences = %d", my_output->seq_number);
your_output = model_label_generate_sequences(mo, 0, seqlen, 1, seqlen);
error = gradient_descent(&mo, your_output, .02, i);
path = viterbi(mo, my_output->seq[0], my_output->seq_len[0], &log_p);
free(path);
/*reestimate_baum_welch_label(mo, my_output);*/
/*reestimate_baum_welch(mo, my_output);*/
/*reruns viterbi to check the training*/
printf("run viterbi second\n");
path = viterbi(mo, my_output->seq[0], my_output->seq_len[0], &log_p);
for (i=0; i<(my_output->seq_len[0]*mo->N); i++){
if (path[i] != -1) {printf("%d", path[i]);}
}
printf("\n");
printf("log-prob: %g\n",log_p);
/* freeing memory */
model_free(&mo);
free(path);
/*printf("sequence_free success: %d\n", */sequence_free(&my_output)/*)*/;
free(my_output);
}
