static void calculate_bounds_data(struct obs_scene_item *item,
struct vec2 *origin, struct vec2 *scale,
uint32_t *cx, uint32_t *cy)
{
float width = (float)(*cx) * fabsf(scale->x);
float height = (float)(*cy) * fabsf(scale->y);
float item_aspect = width / height;
float bounds_aspect = item->bounds.x / item->bounds.y;
uint32_t bounds_type = item->bounds_type;
float width_diff, height_diff;
if (item->bounds_type == OBS_BOUNDS_MAX_ONLY)
if (width > item->bounds.x || height > item->bounds.y)
bounds_type = OBS_BOUNDS_SCALE_INNER;
if (bounds_type == OBS_BOUNDS_SCALE_INNER ||
bounds_type == OBS_BOUNDS_SCALE_OUTER) {
bool use_width = (bounds_aspect < item_aspect);
float mul;
if (item->bounds_type == OBS_BOUNDS_SCALE_OUTER)
use_width = !use_width;
mul = use_width ?
item->bounds.x / width :
item->bounds.y / height;
vec2_mulf(scale, scale, mul);
} else if (bounds_type == OBS_BOUNDS_SCALE_TO_WIDTH) {
vec2_mulf(scale, scale, item->bounds.x / width);
} else if (bounds_type == OBS_BOUNDS_SCALE_TO_HEIGHT) {
vec2_mulf(scale, scale, item->bounds.y / height);
} else if (bounds_type == OBS_BOUNDS_STRETCH) {
scale->x = item->bounds.x / (float)(*cx);
scale->y = item->bounds.y / (float)(*cy);
}
width = (float)(*cx) * scale->x;
height = (float)(*cy) * scale->y;
width_diff = item->bounds.x - width;
height_diff = item->bounds.y - height;
*cx = (uint32_t)item->bounds.x;
*cy = (uint32_t)item->bounds.y;
add_alignment(origin, item->bounds_align,
(int)-width_diff, (int)-height_diff);
}
void add_alignment_patterns ( char **pattern, int version ) //add
{
int i;
int j;
int x = 4; //begin of dark array
for ( i = 0; i < alignment_patterns[version][0]; i++ )
{
for ( j = 0; j < alignment_patterns[version][0]; j++ )
{
if ( test_alignment ( pattern, alignment_patterns[version][i + 1], alignment_patterns[version][j + 1] ) == 0 )
add_alignment( pattern, alignment_patterns[version][i + 1], alignment_patterns[version][j + 1] );
}
}
}
static void update_item_transform(struct obs_scene_item *item)
{
uint32_t width = obs_source_get_width(item->source);
uint32_t height = obs_source_get_height(item->source);
uint32_t cx = calc_cx(item, width);
uint32_t cy = calc_cy(item, height);
struct vec2 base_origin;
struct vec2 origin;
struct vec2 scale = item->scale;
struct calldata params;
uint8_t stack[128];
if (os_atomic_load_long(&item->defer_update) > 0)
return;
width = cx;
height = cy;
vec2_zero(&base_origin);
vec2_zero(&origin);
/* ----------------------- */
if (item->bounds_type != OBS_BOUNDS_NONE) {
calculate_bounds_data(item, &origin, &scale, &cx, &cy);
} else {
cx = (uint32_t)((float)cx * scale.x);
cy = (uint32_t)((float)cy * scale.y);
}
add_alignment(&origin, item->align, (int)cx, (int)cy);
matrix4_identity(&item->draw_transform);
matrix4_scale3f(&item->draw_transform, &item->draw_transform,
scale.x, scale.y, 1.0f);
matrix4_translate3f(&item->draw_transform, &item->draw_transform,
-origin.x, -origin.y, 0.0f);
matrix4_rotate_aa4f(&item->draw_transform, &item->draw_transform,
0.0f, 0.0f, 1.0f, RAD(item->rot));
matrix4_translate3f(&item->draw_transform, &item->draw_transform,
item->pos.x, item->pos.y, 0.0f);
item->output_scale = scale;
/* ----------------------- */
if (item->bounds_type != OBS_BOUNDS_NONE) {
vec2_copy(&scale, &item->bounds);
} else {
scale.x = (float)width * item->scale.x;
scale.y = (float)height * item->scale.y;
}
add_alignment(&base_origin, item->align, (int)scale.x, (int)scale.y);
matrix4_identity(&item->box_transform);
matrix4_scale3f(&item->box_transform, &item->box_transform,
scale.x, scale.y, 1.0f);
matrix4_translate3f(&item->box_transform, &item->box_transform,
-base_origin.x, -base_origin.y, 0.0f);
matrix4_rotate_aa4f(&item->box_transform, &item->box_transform,
0.0f, 0.0f, 1.0f, RAD(item->rot));
matrix4_translate3f(&item->box_transform, &item->box_transform,
item->pos.x, item->pos.y, 0.0f);
/* ----------------------- */
item->last_width = width;
item->last_height = height;
calldata_init_fixed(¶ms, stack, sizeof(stack));
calldata_set_ptr(¶ms, "scene", item->parent);
calldata_set_ptr(¶ms, "item", item);
signal_handler_signal(item->parent->source->context.signals,
"item_transform", ¶ms);
}
static void recalculate_transition_matrix(obs_source_t *tr, size_t idx)
{
obs_source_t *child;
struct matrix4 mat;
struct vec2 pos;
struct vec2 scale;
float tr_cx = (float)tr->transition_actual_cx;
float tr_cy = (float)tr->transition_actual_cy;
float source_cx;
float source_cy;
float tr_aspect = tr_cx / tr_cy;
float source_aspect;
enum obs_transition_scale_type scale_type = tr->transition_scale_type;
lock_transition(tr);
child = tr->transition_sources[idx];
if (!child) {
unlock_transition(tr);
return;
}
source_cx = (float)obs_source_get_width(child);
source_cy = (float)obs_source_get_height(child);
unlock_transition(tr);
if (source_cx == 0.0f || source_cy == 0.0f)
return;
source_aspect = source_cx / source_cy;
if (scale_type == OBS_TRANSITION_SCALE_MAX_ONLY) {
if (source_cx > tr_cx || source_cy > tr_cy) {
scale_type = OBS_TRANSITION_SCALE_ASPECT;
} else {
scale.x = 1.0f;
scale.y = 1.0f;
}
}
if (scale_type == OBS_TRANSITION_SCALE_ASPECT) {
bool use_width = tr_aspect < source_aspect;
scale.x = scale.y = use_width ?
tr_cx / source_cx :
tr_cy / source_cy;
} else if (scale_type == OBS_TRANSITION_SCALE_STRETCH) {
scale.x = tr_cx / source_cx;
scale.y = tr_cy / source_cy;
}
source_cx *= scale.x;
source_cy *= scale.y;
vec2_zero(&pos);
add_alignment(&pos, tr->transition_alignment,
(int)(tr_cx - source_cx),
(int)(tr_cy - source_cy));
matrix4_identity(&mat);
matrix4_scale3f(&mat, &mat, scale.x, scale.y, 1.0f);
matrix4_translate3f(&mat, &mat, pos.x, pos.y, 0.0f);
matrix4_copy(&tr->transition_matrices[idx], &mat);
}
int main(int argc, char** argv) {
std::int8_t m = 5;
std::int8_t n = -4;
std::int8_t g = -8;
std::int8_t e = -6;
std::int8_t q = -10;
std::int8_t c = -4;
std::uint8_t algorithm = 0;
std::uint8_t result = 0;
std::string dot_path = "";
char opt;
while ((opt = getopt_long(argc, argv, "m:n:g:e:q:c:l:r:d:h", options, nullptr)) != -1) {
switch (opt) {
case 'm': m = atoi(optarg); break;
case 'n': n = atoi(optarg); break;
case 'g': g = atoi(optarg); break;
case 'e': e = atoi(optarg); break;
case 'q': q = atoi(optarg); break;
case 'c': c = atoi(optarg); break;
case 'l': algorithm = atoi(optarg); break;
case 'r': result = atoi(optarg); break;
case 'd': dot_path = optarg; break;
case 'v': std::cout << version << std::endl; return 0;
case 'h': help(); return 0;
default: return 1;
}
}
if (optind >= argc) {
std::cerr << "[spoa::] error: missing input file!" << std::endl;
help();
return 1;
}
std::string sequences_path = argv[optind];
auto is_suffix = [](const std::string& src, const std::string& suffix) -> bool {
if (src.size() < suffix.size()) {
return false;
}
return src.compare(src.size() - suffix.size(), suffix.size(), suffix) == 0;
};
std::unique_ptr<bioparser::Parser<spoa::Sequence>> sparser = nullptr;
if (is_suffix(sequences_path, ".fasta") || is_suffix(sequences_path, ".fa") ||
is_suffix(sequences_path, ".fasta.gz") || is_suffix(sequences_path, ".fa.gz")) {
sparser = bioparser::createParser<bioparser::FastaParser, spoa::Sequence>(
sequences_path);
} else if (is_suffix(sequences_path, ".fastq") || is_suffix(sequences_path, ".fq") ||
is_suffix(sequences_path, ".fastq.gz") || is_suffix(sequences_path, ".fq.gz")) {
sparser = bioparser::createParser<bioparser::FastqParser, spoa::Sequence>(
sequences_path);
} else {
std::cerr << "[spoa::] error: file " << sequences_path <<
" has unsupported format extension (valid extensions: .fasta, "
".fasta.gz, .fa, .fa.gz, .fastq, .fastq.gz, .fq, .fq.gz)!" <<
std::endl;
return 1;
}
std::unique_ptr<spoa::AlignmentEngine> alignment_engine;
try {
alignment_engine = spoa::createAlignmentEngine(
static_cast<spoa::AlignmentType>(algorithm), m, n, g, e, q, c);
} catch(std::invalid_argument& exception) {
std::cerr << exception.what() << std::endl;
return 1;
}
auto graph = spoa::createGraph();
std::vector<std::unique_ptr<spoa::Sequence>> sequences;
sparser->parse(sequences, -1);
std::size_t max_sequence_size = 0;
for (const auto& it: sequences) {
max_sequence_size = std::max(max_sequence_size, it->data().size());
}
alignment_engine->prealloc(max_sequence_size, 4);
for (const auto& it: sequences) {
auto alignment = alignment_engine->align(it->data(), graph);
try {
graph->add_alignment(alignment, it->data(), it->quality());
} catch(std::invalid_argument& exception) {
std::cerr << exception.what() << std::endl;
return 1;
}
}
if (result == 0 || result == 2) {
std::string consensus = graph->generate_consensus();
std::cout << "Consensus (" << consensus.size() << ")" << std::endl;
std::cout << consensus << std::endl;
}
if (result == 1 || result == 2) {
std::vector<std::string> msa;
graph->generate_multiple_sequence_alignment(msa);
std::cout << "Multiple sequence alignment" << std::endl;
for (const auto& it: msa) {
std::cout << it << std::endl;
}
}
graph->print_dot(dot_path);
return 0;
}
