void LinearGradient::SetStartAndEndPosition( const Vector2& startPosition, const Vector2& endPosition )
{
mStartPosition = startPosition;
mEndPosition = endPosition;
// Calculate the transform aligning to the gradient line
float dx = mEndPosition.x - mStartPosition.x;
float dy = mEndPosition.y - mStartPosition.y;
Matrix3 alignMatrix( dy, -dx, 0.f, dx, dy, 0.f, mStartPosition.x, mStartPosition.y, 1.f );
alignMatrix.Invert();
mAlignmentTransform = alignMatrix;
}
double GRN::aminoASAlignment(std::string s, int s_size, std::string t, int t_size){
double G_ = gap;
double _G = gap;
double normalization_s = 0;
double normalization_t = 0;
double similarity = 0;
std::vector< std::vector<double> > alignMatrix (t_size, std::vector<double>(s_size));
//initialize alignMatrix;
alignMatrix[0][0] = 0;
for (int i = 1; i != t_size; ++i) {
alignMatrix[i][0] = alignMatrix[i - 1][0] + G_;
}
for (int j = 1; j != s_size; ++j) {
alignMatrix[0][j] = alignMatrix[0][j - 1] + _G;
}
for (int i = 1; i != t_size; ++i) {
for (int j = 1; j != s_size; ++j) {
//alignMatrix[i][j] = maxValue(alignMatrix[i-1][j-1] + alignScore(s[j],t[i]), alignMatrix[i-1][j] + alignScore(s[j], ' '), alignMatrix[i][j-1] + alignScore(' ', t[i]));
double st = 0;
double s_ = 0;
double _t = 0;
st = alignMatrix[i - 1][j - 1] + alignScore(s[j], t[i]);
s_ = alignMatrix[i - 1][j] + alignScore(s[j], ' ');
_t = alignMatrix[i][j - 1] + alignScore(' ', t[i]);
alignMatrix[i][j] = maxValue(st, s_, _t);
}
}
//normalize alignment score;
for (int i = 1; i != s_size; ++i) {
normalization_s += alignScore(s[i], s[i]);
}
for (int i = 0; i != t_size; ++i) {
normalization_t += alignScore(t[i], t[i]);
}
similarity = fabs(2 * alignMatrix[t_size - 1][s_size - 1]) / (normalization_s + normalization_t);
return similarity;
}
void CreateCastingShapes(DemoEntityManager* const scene, dFloat size)
{
NewtonWorld* const world = scene->GetNewton();
int materialID = NewtonMaterialGetDefaultGroupID(world);
dSetRandSeed (0);
dVector shapeSize (size, size, size, 0.0f);
PrimitiveType castSelection[] = {_SPHERE_PRIMITIVE, _CAPSULE_PRIMITIVE, _BOX_PRIMITIVE, _CYLINDER_PRIMITIVE, _REGULAR_CONVEX_HULL_PRIMITIVE, _CHAMFER_CYLINDER_PRIMITIVE};
m_count = sizeof (castSelection) / sizeof (castSelection[0]);
m_castingGeometries = new DemoMesh*[m_count];
m_castingShapeArray = new NewtonCollision*[m_count];
dMatrix alignMatrix (dRollMatrix(3.141592f * 90.0f / 180.0f));
for (int i = 0; i < m_count; i ++) {
dVector shapeSize (size + RandomVariable (size / 2.0f), size + RandomVariable (size / 2.0f), size + RandomVariable (size / 2.0f), 0.0f);
#if 1
m_castingShapeArray[i] = CreateConvexCollision (world, &alignMatrix[0][0], shapeSize, castSelection[i], materialID);
#else
m_castingShapeArray[i] = NewtonCreateCompoundCollision (world, materialID);
NewtonCompoundCollisionBeginAddRemove(m_castingShapeArray[i]);
NewtonCollision* const collision = CreateConvexCollision (world, &alignMatrix[0][0], shapeSize, castSelection[i], materialID);
NewtonCompoundCollisionAddSubCollision (m_castingShapeArray[i], collision);
NewtonDestroyCollision(collision);
NewtonCompoundCollisionEndAddRemove(m_castingShapeArray[i]);
#endif
m_castingGeometries[i] = new DemoMesh("geometry", m_castingShapeArray[i], "smilli.tga", "smilli.tga", "smilli.tga");
}
// make and entity for showing the result of the convex cast
dMatrix matrix (dGetIdentityMatrix());
matrix.m_posit.m_y = 2.0f;
m_currentCastingShape = 0;
m_castingEntity = new DemoEntity (matrix, NULL);
m_castingEntity->SetMesh(m_castingGeometries[m_currentCastingShape], dGetIdentityMatrix());
}
double Perseus::basicPairwiseAlignSeqs(string query, string reference, string& qAlign, string& rAlign, pwModel model){
try {
double GAP = model.GAP_OPEN;
double MATCH = model.MATCH;
double MISMATCH = model.MISMATCH;
int queryLength = query.size();
int refLength = reference.size();
vector<vector<double> > alignMatrix(queryLength + 1);
vector<vector<char> > alignMoves(queryLength + 1);
for(int i=0;i<=queryLength;i++){
if (m->getControl_pressed()) { return 0; }
alignMatrix[i].resize(refLength + 1, 0);
alignMoves[i].resize(refLength + 1, 'x');
}
for(int i=0;i<=queryLength;i++){
if (m->getControl_pressed()) { return 0; }
alignMatrix[i][0] = GAP * i;
alignMoves[i][0] = 'u';
}
for(int i=0;i<=refLength;i++){
if (m->getControl_pressed()) { return 0; }
alignMatrix[0][i] = GAP * i;
alignMoves[0][i] = 'l';
}
for(int i=1;i<=queryLength;i++){
if (m->getControl_pressed()) { return 0; }
for(int j=1;j<=refLength;j++){
double nogapScore;
if(query[i-1] == reference[j-1]){ nogapScore = alignMatrix[i-1][j-1] + MATCH; }
else { nogapScore = alignMatrix[i-1][j-1] + MISMATCH; }
double leftScore;
if(i == queryLength) { leftScore = alignMatrix[i][j-1]; }
else { leftScore = alignMatrix[i][j-1] + GAP; }
double upScore;
if(j == refLength) { upScore = alignMatrix[i-1][j]; }
else { upScore = alignMatrix[i-1][j] + GAP; }
if(nogapScore > leftScore){
if(nogapScore > upScore){
alignMoves[i][j] = 'd';
alignMatrix[i][j] = nogapScore;
}
else{
alignMoves[i][j] = 'u';
alignMatrix[i][j] = upScore;
}
}
else{
if(leftScore > upScore){
alignMoves[i][j] = 'l';
alignMatrix[i][j] = leftScore;
}
else{
alignMoves[i][j] = 'u';
alignMatrix[i][j] = upScore;
}
}
}
}
int i = queryLength;
int j = refLength;
qAlign = "";
rAlign = "";
int diffs = 0;
int length = 0;
while(i > 0 && j > 0){
if (m->getControl_pressed()) { return 0; }
if(alignMoves[i][j] == 'd'){
qAlign = query[i-1] + qAlign;
rAlign = reference[j-1] + rAlign;
if(query[i-1] != reference[j-1]){ diffs++; }
length++;
i--;
j--;
}
else if(alignMoves[i][j] == 'u'){
qAlign = query[i-1] + qAlign;
if(j != refLength) { rAlign = '-' + rAlign; diffs++; length++; }
else { rAlign = '.' + rAlign; }
i--;
}
else if(alignMoves[i][j] == 'l'){
rAlign = reference[j-1] + rAlign;
if(i != queryLength){ qAlign = '-' + qAlign; diffs++; length++; }
else { qAlign = '.' + qAlign; }
j--;
}
}
while(i>0){
if (m->getControl_pressed()) { return 0; }
rAlign = '.' + rAlign;
qAlign = query[i-1] + qAlign;
i--;
}
while(j>0){
if (m->getControl_pressed()) { return 0; }
rAlign = reference[j-1] + rAlign;
qAlign = '.' + qAlign;
j--;
}
return double(diffs)/double(length);
}
catch(exception& e) {
m->errorOut(e, "Perseus", "basicPairwiseAlignSeqs");
exit(1);
}
}
double Perseus::modeledPairwiseAlignSeqs(string query, string reference, string& qAlign, string& rAlign, vector<vector<double> >& correctMatrix){
try {
int queryLength = query.size();
int refLength = reference.size();
vector<vector<double> > alignMatrix(queryLength + 1);
vector<vector<char> > alignMoves(queryLength + 1);
for(int i=0;i<=queryLength;i++){
if (m->getControl_pressed()) { return 0; }
alignMatrix[i].resize(refLength + 1, 0);
alignMoves[i].resize(refLength + 1, 'x');
}
for(int i=0;i<=queryLength;i++){
if (m->getControl_pressed()) { return 0; }
alignMatrix[i][0] = 15.0 * i;
alignMoves[i][0] = 'u';
}
for(int i=0;i<=refLength;i++){
if (m->getControl_pressed()) { return 0; }
alignMatrix[0][i] = 15.0 * i;
alignMoves[0][i] = 'l';
}
for(int i=1;i<=queryLength;i++){
if (m->getControl_pressed()) { return 0; }
for(int j=1;j<=refLength;j++){
double nogap;
nogap = alignMatrix[i-1][j-1] + correctMatrix[toInt(query[i-1])][toInt(reference[j-1])];
double gap;
double left;
if(i == queryLength){ //terminal gap
left = alignMatrix[i][j-1];
}
else{
if(reference[j-1] == getLastMatch('l', alignMoves, i, j, query, reference)){
gap = 4.0;
}
else{
gap = 15.0;
}
left = alignMatrix[i][j-1] + gap;
}
double up;
if(j == refLength){ //terminal gap
up = alignMatrix[i-1][j];
}
else{
if(query[i-1] == getLastMatch('u', alignMoves, i, j, query, reference)){
gap = 4.0;
}
else{
gap = 15.0;
}
up = alignMatrix[i-1][j] + gap;
}
if(nogap < left){
if(nogap < up){
alignMoves[i][j] = 'd';
alignMatrix[i][j] = nogap;
}
else{
alignMoves[i][j] = 'u';
alignMatrix[i][j] = up;
}
}
else{
if(left < up){
alignMoves[i][j] = 'l';
alignMatrix[i][j] = left;
}
else{
alignMoves[i][j] = 'u';
alignMatrix[i][j] = up;
}
}
}
}
int i = queryLength;
int j = refLength;
int alignLength = 0;
while(i > 0 && j > 0){
if (m->getControl_pressed()) { return 0; }
if(alignMoves[i][j] == 'd'){
qAlign = query[i-1] + qAlign;
rAlign = reference[j-1] + rAlign;
alignLength++;
i--;
j--;
}
else if(alignMoves[i][j] == 'u'){
if(j != refLength){
qAlign = query[i-1] + qAlign;
rAlign = '-' + rAlign;
alignLength++;
}
i--;
}
else if(alignMoves[i][j] == 'l'){
if(i != queryLength){
qAlign = '-' + qAlign;
rAlign = reference[j-1] + rAlign;
alignLength++;
}
j--;
}
}
return alignMatrix[queryLength][refLength] / (double)alignLength;
}
catch(exception& e) {
m->errorOut(e, "Perseus", "modeledPairwiseAlignSeqs");
exit(1);
}
}
int seqNoise::countDiffs(vector<int> query, vector<int> ref){
try {
//double MATCH = 5.0;
//double MISMATCH = -2.0;
//double GAP = -2.0;
vector<vector<double> > correctMatrix(4);
for(int i=0;i<4;i++){ correctMatrix[i].resize(4); }
correctMatrix[0][0] = 0.000000; //AA
correctMatrix[1][0] = 11.619259; //CA
correctMatrix[2][0] = 11.694004; //TA
correctMatrix[3][0] = 7.748623; //GA
correctMatrix[1][1] = 0.000000; //CC
correctMatrix[2][1] = 7.619657; //TC
correctMatrix[3][1] = 12.852562; //GC
correctMatrix[2][2] = 0.000000; //TT
correctMatrix[3][2] = 10.964048; //TG
correctMatrix[3][3] = 0.000000; //GG
for(int i=0;i<4;i++){
for(int j=0;j<i;j++){
correctMatrix[j][i] = correctMatrix[i][j];
}
}
int queryLength = query.size();
int refLength = ref.size();
vector<vector<double> > alignMatrix(queryLength + 1);
vector<vector<char> > alignMoves(queryLength + 1);
for(int i=0;i<=queryLength;i++){
if (m->control_pressed) { return 0; }
alignMatrix[i].resize(refLength + 1, 0);
alignMoves[i].resize(refLength + 1, 'x');
}
for(int i=0;i<=queryLength;i++){
if (m->control_pressed) { return 0; }
alignMatrix[i][0] = 15.0 * i;
alignMoves[i][0] = 'u';
}
for(int i=0;i<=refLength;i++){
if (m->control_pressed) { return 0; }
alignMatrix[0][i] = 15.0 * i;
alignMoves[0][i] = 'l';
}
for(int i=1;i<=queryLength;i++){
if (m->control_pressed) { return 0; }
for(int j=1;j<=refLength;j++){
double nogap;
nogap = alignMatrix[i-1][j-1] + correctMatrix[query[i-1]][ref[j-1]];
double gap;
double left;
if(i == queryLength){ //terminal gap
left = alignMatrix[i][j-1];
}
else{
if(ref[j-1] == getLastMatch('l', alignMoves, i, j, query, ref)){
gap = 4.0;
}
else{
gap = 15.0;
}
left = alignMatrix[i][j-1] + gap;
}
double up;
if(j == refLength){ //terminal gap
up = alignMatrix[i-1][j];
}
else{
if(query[i-1] == getLastMatch('u', alignMoves, i, j, query, ref)){
gap = 4.0;
}
else{
gap = 15.0;
}
up = alignMatrix[i-1][j] + gap;
}
if(nogap < left){
if(nogap < up){
alignMoves[i][j] = 'd';
alignMatrix[i][j] = nogap;
}
else{
alignMoves[i][j] = 'u';
alignMatrix[i][j] = up;
}
}
else{
if(left < up){
alignMoves[i][j] = 'l';
alignMatrix[i][j] = left;
}
else{
alignMoves[i][j] = 'u';
alignMatrix[i][j] = up;
}
}
}
}
int i = queryLength;
int j = refLength;
int diffs = 0;
// string alignA = "";
// string alignB = "";
// string bases = "ACTG";
while(i > 0 && j > 0){
if (m->control_pressed) { return 0; }
if(alignMoves[i][j] == 'd'){
// alignA = bases[query[i-1]] + alignA;
// alignB = bases[ref[j-1]] + alignB;
if(query[i-1] != ref[j-1]) { diffs++; }
i--;
j--;
}
else if(alignMoves[i][j] == 'u'){
if(j != refLength){
// alignA = bases[query[i-1]] + alignA;
// alignB = '-' + alignB;
diffs++;
}
i--;
}
else if(alignMoves[i][j] == 'l'){
if(i != queryLength){
// alignA = '-' + alignA;
// alignB = bases[ref[j-1]] + alignB;
diffs++;
}
j--;
}
}
// cout << diffs << endl;
// cout << alignA << endl;
// cout << alignB << endl;
// cout << endl;
return diffs;
}
catch(exception& e) {
m->errorOut(e, "seqNoise", "countDiffs");
exit(1);
}
}
double correctDist::getDist(vector<int>& seqA, vector<int>& seqB){
try {
int lengthA = seqA.size();
int lengthB = seqB.size();
vector<vector<double> > alignMatrix(lengthA+1);
vector<vector<char> > alignMoves(lengthA+1);
for(int i=0;i<=lengthA;i++){
alignMatrix[i].resize(lengthB+1, 0);
alignMoves[i].resize(lengthB+1, 'x');
}
for(int i=0;i<=lengthA;i++){
alignMatrix[i][0] = 15.0 * i;
alignMoves[i][0] = 'u';
}
for(int i=0;i<=lengthB;i++){
alignMatrix[0][i] = 15.0 * i;
alignMoves[0][i] = 'l';
}
for(int i=1;i<=lengthA;i++){
for(int j=1;j<=lengthB;j++){
if (m->control_pressed) { return 0; }
double nogap;
nogap = alignMatrix[i-1][j-1] + correctMatrix[seqA[i-1]][seqB[j-1]];
double gap;
double left;
if(i == lengthA){ //terminal gap
left = alignMatrix[i][j-1];
}
else{
if(seqB[j-1] == getLastMatch('l', alignMoves, i, j, seqA, seqB)){
gap = 4.0;
}
else{
gap = 15.0;
}
left = alignMatrix[i][j-1] + gap;
}
double up;
if(j == lengthB){ //terminal gap
up = alignMatrix[i-1][j];
}
else{
if(seqA[i-1] == getLastMatch('u', alignMoves, i, j, seqA, seqB)){
gap = 4.0;
}
else{
gap = 15.0;
}
up = alignMatrix[i-1][j] + gap;
}
if(nogap < left){
if(nogap < up){
alignMoves[i][j] = 'd';
alignMatrix[i][j] = nogap;
}
else{
alignMoves[i][j] = 'u';
alignMatrix[i][j] = up;
}
}
else{
if(left < up){
alignMoves[i][j] = 'l';
alignMatrix[i][j] = left;
}
else{
alignMoves[i][j] = 'u';
alignMatrix[i][j] = up;
}
}
}
}
int i = lengthA;
int j = lengthB;
int count = 0;
// string alignA = "";
// string alignB = "";
// string bases = "ACTG";
//
// for(int i=0;i<lengthA;i++){
// cout << bases[seqA[i]];
// }cout << endl;
//
// for(int i=0;i<lengthB;i++){
// cout << bases[seqB[i]];
// }cout << endl;
while(i > 0 && j > 0){
if (m->control_pressed) { return 0; }
if(alignMoves[i][j] == 'd'){
// alignA = bases[seqA[i-1]] + alignA;
// alignB = bases[seqB[j-1]] + alignB;
count++;
i--;
j--;
}
else if(alignMoves[i][j] == 'u'){
if(j != lengthB){
// alignA = bases[seqA[i-1]] + alignA;
// alignB = '-' + alignB;
count++;
}
i--;
}
else if(alignMoves[i][j] == 'l'){
if(i != lengthA){
// alignA = '-' + alignA;
// alignB = bases[seqB[j-1]] + alignB;
count++;
}
j--;
}
}
// cout << alignA << endl << alignB << endl;
return alignMatrix[lengthA][lengthB] / (double)count;
}
catch(exception& e) {
m->errorOut(e, "correctDist", "getDist");
exit(1);
}
}
