16 Commits

Author SHA1 Message Date
01613d1977 Implement simple hole stencil to resolve holes in GDS polygons. 2022-04-19 22:14:52 +02:00
a6899a3f7c Add poly2tri and C++ wrapper for polygon tesselation. 2022-04-19 20:04:08 +02:00
4aa63db8dd Start preview feature. Add dummy triangle to test OpenGL. 2022-04-18 17:14:27 +02:00
f42d61192a Add preview rendering skeleton 2022-04-18 14:17:21 +02:00
8b1f667819 Merge pull request 'issue/47-add-vertex-count-to-gui' (#48) from issue/47-add-vertex-count-to-gui into dev
Reviewed-on: #48
2022-04-17 20:09:47 +02:00
c2ca2ff573 Rework the analysis cmd option to work with new statistics functions 2022-04-17 20:07:57 +02:00
c0ac6cc3c5 Move statistic calculation to parser. Show Vertex and GFX count in GUI. CLI -A param is now broken. Will implement in next commits. 2022-04-17 18:37:32 +02:00
22bc3a18d7 Issue #47: Add renderer for cell statistics and render dummy value 2022-04-17 17:40:18 +02:00
dbc9fcdf34 Issue #47: AddVertex count column to tree view 2022-04-17 16:54:57 +02:00
b39030aeaa Fix PKGBUILD 2022-04-17 00:47:41 +02:00
2f59a762cd Fix PKGBUILD 2022-04-17 00:46:51 +02:00
ab26f8a2af Fix PKGBUILD 2022-04-17 00:45:49 +02:00
9a43cd53f8 Update PKGBUILD 2022-04-17 00:38:50 +02:00
ba6b07c8a2 Implement cell statistics command line interface 2022-04-17 00:37:26 +02:00
1548c82542 Add libfort for pretty console tables 2022-04-16 16:13:22 +02:00
fb6d31c120 Fix stuck at -1 return value when executing command line interface 2022-04-16 16:00:50 +02:00
29 changed files with 1212 additions and 28 deletions

7
.gitmodules vendored
View File

@@ -2,3 +2,10 @@
path = c-style-checker path = c-style-checker
url = https://git.shimatta.de/mhu/c-style-checker url = https://git.shimatta.de/mhu/c-style-checker
branch = master branch = master
[submodule "3rdparty/libfort"]
path = 3rdparty/libfort
url = https://git.shimatta.de/3rd-party/libfort
branch = develop
[submodule "3rdparty/poly2tri"]
path = 3rdparty/poly2tri
url = https://git.shimatta.de/3rd-party/poly2tri.git

1
3rdparty/libfort vendored Submodule

Submodule 3rdparty/libfort added at 41237162a9

1
3rdparty/poly2tri vendored Submodule

Submodule 3rdparty/poly2tri added at 3380f5c805

View File

@@ -10,8 +10,8 @@ licence=('GPLv2')
depends=('glib2' 'gtk3' 'cairo') depends=('glib2' 'gtk3' 'cairo')
makedepends=('cmake' 'git') makedepends=('cmake' 'git')
privides=('gds-render') privides=('gds-render')
source=("${pkgname}-git"::"git+https://git.shimatta.de/mhu/gds-render.git") source=("${pkgname}-git"::"git+https://git.shimatta.de/mhu/gds-render.git" "https://git.shimatta.de/3rd-party/libfort.git")
sha1sums=('SKIP') sha1sums=('SKIP' 'SKIP')
pkgver () { pkgver () {
_date=`date +"%Y%m%d"` _date=`date +"%Y%m%d"`
@@ -26,6 +26,13 @@ build () {
make make
} }
prepare () {
cd "${pkgname}-git"
git submodule init
git config submodule.libfort.url "$srcdir/libfort"
git submodule update
}
package () { package () {
cd "$srcdir/$pkgname-git/build" cd "$srcdir/$pkgname-git/build"
make DESTDIR="${pkgdir}" install make DESTDIR="${pkgdir}" install

View File

@@ -1,4 +1,8 @@
project(gds-render) if (POLICY CMP0048)
cmake_policy(SET CMP0048 NEW)
endif (POLICY CMP0048)
project(gds-render LANGUAGES C CXX)
if(CMAKE_INSTALL_PREFIX_INITIALIZED_TO_DEFAULT) if(CMAKE_INSTALL_PREFIX_INITIALIZED_TO_DEFAULT)
set(CMAKE_INSTALL_PREFIX "/usr/" CACHE PATH "..." FORCE) set(CMAKE_INSTALL_PREFIX "/usr/" CACHE PATH "..." FORCE)
@@ -24,7 +28,7 @@ if(NOT WIN32)
set(BoldWhite "${Esc}[1;37m") set(BoldWhite "${Esc}[1;37m")
endif() endif()
cmake_minimum_required(VERSION 2.8) cmake_minimum_required(VERSION 3.0)
find_package(PkgConfig REQUIRED) find_package(PkgConfig REQUIRED)
pkg_search_module(GLIB REQUIRED glib-2.0) pkg_search_module(GLIB REQUIRED glib-2.0)
pkg_check_modules(GTK3 REQUIRED gtk+-3.0) pkg_check_modules(GTK3 REQUIRED gtk+-3.0)
@@ -71,12 +75,21 @@ SET_SOURCE_FILES_PROPERTIES(${SOURCE_GENERATED} PROPERTIES GENERATED 1)
add_subdirectory(test) add_subdirectory(test)
add_compile_options(-Wall -Wextra -Wold-style-declaration -Wuninitialized -Wmaybe-uninitialized -Wunused-parameter)
add_subdirectory(resources) add_subdirectory(resources)
add_subdirectory(doxygen) add_subdirectory(doxygen)
add_subdirectory(translations) add_subdirectory(translations)
add_subdirectory(version) add_subdirectory(version)
set(FORT_ENABLE_TESTING OFF CACHE INTERNAL "")
add_subdirectory(3rdparty/libfort)
if(OPENGL_PREVIEW)
message("${Green}OpenGL preview activated${ColorReset}")
add_definitions(-DGDS_RENDER_OPGENGL_PREVIEW)
add_subdirectory(preview-rendering)
endif(OPENGL_PREVIEW)
add_compile_options(-Wall -Wextra -Wold-style-declaration -Wuninitialized -Wmaybe-uninitialized -Wunused-parameter)
link_directories(${GLIB_LINK_DIRS} ${GTK3_LINK_DIRS} ${CAIRO_LINK_DIRS}) link_directories(${GLIB_LINK_DIRS} ${GTK3_LINK_DIRS} ${CAIRO_LINK_DIRS})
add_definitions(${GLIB2_CFLAGS_OTHER}) add_definitions(${GLIB2_CFLAGS_OTHER})
@@ -85,10 +98,14 @@ add_executable(${PROJECT_NAME} ${SOURCE} ${SOURCE_GENERATED})
add_dependencies(${PROJECT_NAME} glib-resources) add_dependencies(${PROJECT_NAME} glib-resources)
add_dependencies(${PROJECT_NAME} version) add_dependencies(${PROJECT_NAME} version)
add_dependencies(${PROJECT_NAME} translations) add_dependencies(${PROJECT_NAME} translations)
if(OPENGL_PREVIEW)
add_dependencies(${PROJECT_NAME} opengl-preview)
target_link_libraries(${PROJECT_NAME} opengl-preview)
endif(OPENGL_PREVIEW)
install (TARGETS ${PROJECT_NAME} install (TARGETS ${PROJECT_NAME}
RUNTIME RUNTIME
DESTINATION bin DESTINATION bin
) )
target_link_libraries(${PROJECT_NAME} ${GLIB_LDFLAGS} ${GTK3_LDFLAGS} ${CAIRO_LDFLAGS} m version ${CMAKE_DL_LIBS}) target_link_libraries(${PROJECT_NAME} ${GLIB_LDFLAGS} ${GTK3_LDFLAGS} ${CAIRO_LDFLAGS} m version ${CMAKE_DL_LIBS} fort)

View File

@@ -0,0 +1,106 @@
/*
* GDSII-Converter
* Copyright (C) 2022 Mario Hüttel <mario.huettel@gmx.net>
*
* This file is part of GDSII-Converter.
*
* GDSII-Converter is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2 as
* published by the Free Software Foundation.
*
* GDSII-Converter is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with GDSII-Converter. If not, see <http://www.gnu.org/licenses/>.
*/
/**
* @file cell-statistics-renderer.c
* @brief CellStatisticsRenderer GObject Class
* @author Mario Hüttel <mario.huettel@gmx.net>
*/
/**
* @addtogroup CellStatisticsRenderer
* @{
*/
#include <gds-render/cell-selector/cell-statistics-renderer.h>
G_DEFINE_TYPE(CellStatisticsRenderer, cell_statistics_renderer, GTK_TYPE_CELL_RENDERER_TEXT)
enum {
PROP_CELL_STAT = 1,
PROP_COUNT
};
static void cell_statistics_renderer_set_property(GObject *object,
guint param_id,
const GValue *value,
GParamSpec *pspec)
{
GValue val = G_VALUE_INIT;
GString *string;
const struct gds_cell_statistics *cell_stat;
switch (param_id) {
case PROP_CELL_STAT:
cell_stat = (const struct gds_cell_statistics *)g_value_get_pointer(value);
g_value_init(&val, G_TYPE_STRING);
string = g_string_new_len("", 5);
if (cell_stat)
g_string_printf(string, "%zu (%zu) | %zu (%zu)", cell_stat->total_vertex_count,
cell_stat->vertex_count, cell_stat->total_gfx_count, cell_stat->gfx_count);
g_value_set_string(&val, string->str);
g_object_set_property(object, "text", &val);
g_value_unset(&val);
g_string_free(string, TRUE);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID(object, param_id, pspec);
break;
}
}
static void cell_statistics_renderer_get_property(GObject *object,
guint param_id,
GValue *value,
GParamSpec *pspec)
{
(void)value;
switch (param_id) {
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID(object, param_id, pspec);
break;
}
}
static GParamSpec *properties[PROP_COUNT];
void cell_statistics_renderer_class_init(CellStatisticsRendererClass *klass)
{
GObjectClass *oclass = G_OBJECT_CLASS(klass);
oclass->set_property = cell_statistics_renderer_set_property;
oclass->get_property = cell_statistics_renderer_get_property;
properties[PROP_CELL_STAT] = g_param_spec_pointer("cell-stat", "cell-stat",
"Cell statistics", G_PARAM_WRITABLE);
g_object_class_install_properties(oclass, PROP_COUNT, properties);
}
void cell_statistics_renderer_init(CellStatisticsRenderer *self)
{
(void)self;
}
GtkCellRenderer *cell_statistics_renderer_new(void)
{
return GTK_CELL_RENDERER(g_object_new(TYPE_GDS_RENDER_CELL_STAT_RENDERER, NULL));
}
/** @} */

View File

@@ -30,6 +30,7 @@
#include <stdio.h> #include <stdio.h>
#include <glib/gi18n.h> #include <glib/gi18n.h>
#include <string.h>
#include <gds-render/command-line.h> #include <gds-render/command-line.h>
#include <gds-render/gds-utils/gds-parser.h> #include <gds-render/gds-utils/gds-parser.h>
@@ -38,6 +39,41 @@
#include <gds-render/output-renderers/latex-renderer.h> #include <gds-render/output-renderers/latex-renderer.h>
#include <gds-render/output-renderers/external-renderer.h> #include <gds-render/output-renderers/external-renderer.h>
#include <gds-render/gds-utils/gds-tree-checker.h> #include <gds-render/gds-utils/gds-tree-checker.h>
#include <gds-render/gds-utils/gds-statistics.h>
#include <fort.h>
#ifndef COUNT_OF
#define COUNT_OF(x) (sizeof((x))/sizeof(0[(x)]))
#endif
enum analysis_format {
ANA_FORMAT_SIMPLE = 0,
ANA_FORMAT_CELLS_ONLY,
ANA_FORMAT_PRETTY,
};
struct analysis_format_cmdarg {
enum analysis_format format;
const char *argument;
};
static const struct analysis_format_cmdarg analysis_format_lookup[] = {
{
.format = ANA_FORMAT_SIMPLE,
.argument = "simple",
},
{
.format = ANA_FORMAT_PRETTY,
.argument = "pretty",
},
{
.format = ANA_FORMAT_CELLS_ONLY,
.argument = "cellsonly"
}
};
static int string_array_count(char **string_array) static int string_array_count(char **string_array)
{ {
@@ -228,6 +264,8 @@ int command_line_convert_gds(const char *gds_name,
gds_output_renderer_render_output(current_renderer, toplevel_cell, scale); gds_output_renderer_render_output(current_renderer, toplevel_cell, scale);
} }
ret = 0;
ret_destroy_library_list: ret_destroy_library_list:
clear_lib_list(&libs); clear_lib_list(&libs);
ret_clear_renderers: ret_clear_renderers:
@@ -238,4 +276,192 @@ ret_destroy_layer_mapping:
return ret; return ret;
} }
static void indent_line(int level)
{
while (level--)
printf("\t");
}
static int printf_indented(int level, const char *format, ...)
{
int ret;
va_list a_list;
va_start(a_list, format);
indent_line(level);
ret = vprintf(format, a_list);
va_end(a_list);
return ret;
}
static void print_simple_stat(GList *lib_stat_list)
{
int indentation_level = 0;
GList *lib_iter;
GList *cell_iter;
const struct gds_library *lib;
const struct gds_cell *cell;
const struct gds_lib_statistics *lib_stat;
const struct gds_cell_statistics *cell_stat;
for (lib_iter = lib_stat_list; lib_iter; lib_iter = g_list_next(lib_iter)) {
lib = (const struct gds_library *)lib_iter->data;
lib_stat = &lib->stats;
printf_indented(indentation_level, "Library %s\n", lib->name);
indentation_level++;
for (cell_iter = lib->cells; cell_iter; cell_iter = g_list_next(cell_iter)) {
cell = (const struct gds_cell *)cell_iter->data;
cell_stat = &cell->stats;
printf_indented(indentation_level, "Cell %s\n", cell->name);
indentation_level++;
printf_indented(indentation_level, "Reference count: %zu\n", cell_stat->reference_count);
printf_indented(indentation_level, "Graphics count: %zu\n", cell_stat->gfx_count);
printf_indented(indentation_level, "Total Graphics count: %zu\n", cell_stat->total_gfx_count);
printf_indented(indentation_level, "Vertex count: %zu\n", cell_stat->vertex_count);
printf_indented(indentation_level, "Total Vertex count: %zu\n", cell_stat->total_vertex_count);
printf_indented(indentation_level, "Unresolved children: %d\n",
cell->checks.unresolved_child_count);
printf_indented(indentation_level, "Reference loop: %s\n",
cell->checks.affected_by_reference_loop ? "yes" : "no");
indentation_level--;
}
printf_indented(indentation_level, "Cell count: %zu\n", lib_stat->cell_count);
printf_indented(indentation_level, "Reference count: %zu\n", lib_stat->reference_count);
printf_indented(indentation_level, "Graphics count: %zu\n", lib_stat->gfx_count);
printf_indented(indentation_level, "Vertex count: %zu\n", lib_stat->vertex_count);
}
}
static void table_stat_create_cell_row(struct gds_cell *cell, ft_table_t *tab)
{
ft_printf_ln(tab, "%s|%s|%zu|%zu|%zu|%zu|%zu|%d|%s",
cell->parent_library->name,
cell->name,
cell->stats.gfx_count,
cell->stats.total_gfx_count,
cell->stats.vertex_count,
cell->stats.total_vertex_count,
cell->stats.reference_count,
cell->checks.unresolved_child_count,
cell->checks.affected_by_reference_loop ? "yes" : "no");
}
static void table_stat_table_for_lib(struct gds_library *lib, ft_table_t *tab)
{
ft_printf_ln(tab, "%s|%zu|%zu|-|%zu|-|%zu|-|-",
lib->name,
lib->stats.cell_count,
lib->stats.gfx_count,
lib->stats.vertex_count,
lib->stats.reference_count);
g_list_foreach(lib->cells, (GFunc)table_stat_create_cell_row, tab);
}
static void print_table_stat(GList *lib_list)
{
ft_table_t *table;
table = ft_create_table();
ft_set_cell_prop(table, 0, FT_ANY_COLUMN, FT_CPROP_ROW_TYPE, FT_ROW_HEADER);
ft_write_ln(table, "Library", "Cell", "GFX", "GFX+", "Vertices", "Vertices+", "Refs", "Unresolved Refs", "Loops");
g_list_foreach(lib_list, (GFunc)table_stat_table_for_lib, table);
printf("%s\n", ft_to_string(table));
ft_destroy_table(table);
}
static void print_statistics(enum analysis_format format, GList *lib_list)
{
switch (format) {
case ANA_FORMAT_PRETTY:
print_table_stat(lib_list);
break;
default:
print_simple_stat(lib_list);
break;
}
}
static void print_cell_names(GList *lib_list)
{
GList *lib_iter;
GList *name_iter;
struct gds_library *lib;
for (lib_iter = lib_list; lib_iter; lib_iter = g_list_next(lib_iter)) {
lib = (struct gds_library *)lib_iter->data;
for (name_iter = lib->cell_names; name_iter; name_iter = name_iter->next) {
printf("%s\n", (const char *)name_iter->data);
}
}
}
int command_line_analyze_lib(const char *format, const char *gds_name)
{
enum analysis_format fmt = ANA_FORMAT_SIMPLE;
size_t idx;
int found = 0;
GList *lib_list = NULL;
const struct gds_library_parsing_opts parsing_opts = {
.simplified_polygons = 0,
};
int res;
int ret = 0;
GList *lib_iter;
g_return_val_if_fail(gds_name, -1002);
if (format && *format) {
/* Check format if it is not empty */
for (idx = 0; idx < COUNT_OF(analysis_format_lookup); idx++) {
if (!strcmp(analysis_format_lookup[idx].argument, format)) {
/* Format specifier matches */
fmt = analysis_format_lookup[idx].format;
found = 1;
}
}
if (!found) {
fprintf(stderr, "No format matches %s. Using default.\n", format);
}
}
/* Load the GDS file */
res = parse_gds_from_file(gds_name, &lib_list, &parsing_opts);
if (res) {
fprintf(stderr, "Error parsing GDS file\n");
(void)clear_lib_list(&lib_list);
ret = res;
goto return_val;
}
for (lib_iter = lib_list; lib_iter; lib_iter = g_list_next(lib_iter)) {
res = gds_tree_check_cell_references((struct gds_library *)lib_iter->data);
if (res < 0) {
fprintf(stderr, "Error checking cell references. Will continue...\n");
}
res = gds_tree_check_reference_loops((struct gds_library *)lib_iter->data);
if (res < 0) {
fprintf(stderr, "Error checking cell reference loops. Will continue...\n");
}
}
if (fmt == ANA_FORMAT_CELLS_ONLY) {
print_cell_names(lib_list);
goto return_clear_libs;
}
print_statistics(fmt, lib_list);
return_clear_libs:
clear_lib_list(&lib_list);
return_val:
return ret;
}
/** @} */ /** @} */

View File

@@ -37,17 +37,23 @@
#include <gds-render/layer/layer-selector.h> #include <gds-render/layer/layer-selector.h>
#include <gds-render/widgets/activity-bar.h> #include <gds-render/widgets/activity-bar.h>
#include <gds-render/cell-selector/lib-cell-renderer.h> #include <gds-render/cell-selector/lib-cell-renderer.h>
#include <gds-render/cell-selector/cell-statistics-renderer.h>
#include <gds-render/output-renderers/latex-renderer.h> #include <gds-render/output-renderers/latex-renderer.h>
#include <gds-render/output-renderers/cairo-renderer.h> #include <gds-render/output-renderers/cairo-renderer.h>
#include <gds-render/widgets/conv-settings-dialog.h> #include <gds-render/widgets/conv-settings-dialog.h>
#include <gds-render/geometric/cell-geometrics.h> #include <gds-render/geometric/cell-geometrics.h>
#include <gds-render/version.h> #include <gds-render/version.h>
#ifdef GDS_RENDER_OPGENGL_PREVIEW
#include <preview-rendering/preview-rendering-gui.h>
#endif
/** @brief Columns of selection tree view */ /** @brief Columns of selection tree view */
enum cell_store_columns { enum cell_store_columns {
CELL_SEL_LIBRARY = 0, CELL_SEL_LIBRARY = 0,
CELL_SEL_CELL, CELL_SEL_CELL,
CELL_SEL_CELL_ERROR_STATE, /**< Used for cell color and selectability */ CELL_SEL_CELL_ERROR_STATE, /**< Used for cell color and selectability */
CELL_SEL_STAT,
CELL_SEL_COLUMN_COUNT /**< @brief Not a column. Used to determine count of columns */ CELL_SEL_COLUMN_COUNT /**< @brief Not a column. Used to determine count of columns */
}; };
@@ -66,6 +72,9 @@ struct _GdsRenderGui {
/* Custom fields */ /* Custom fields */
GtkWindow *main_window; GtkWindow *main_window;
#ifdef GDS_RENDER_OPGENGL_PREVIEW
OpenGlPreviewGui *preview_gui;
#endif
GtkWidget *convert_button; GtkWidget *convert_button;
GtkWidget *open_button; GtkWidget *open_button;
GtkWidget *load_layer_button; GtkWidget *load_layer_button;
@@ -219,10 +228,11 @@ int gds_render_gui_setup_cell_selector(GdsRenderGui *self)
{ {
GtkCellRenderer *render_cell; GtkCellRenderer *render_cell;
GtkCellRenderer *render_lib; GtkCellRenderer *render_lib;
GtkCellRenderer *render_vertex_count;
GtkTreeViewColumn *column; GtkTreeViewColumn *column;
self->cell_tree_store = gtk_tree_store_new(CELL_SEL_COLUMN_COUNT, G_TYPE_POINTER, self->cell_tree_store = gtk_tree_store_new(CELL_SEL_COLUMN_COUNT, G_TYPE_POINTER,
G_TYPE_POINTER, G_TYPE_UINT); G_TYPE_POINTER, G_TYPE_UINT, G_TYPE_POINTER);
/* Searching */ /* Searching */
self->cell_filter = GTK_TREE_MODEL_FILTER( self->cell_filter = GTK_TREE_MODEL_FILTER(
@@ -238,6 +248,7 @@ int gds_render_gui_setup_cell_selector(GdsRenderGui *self)
render_cell = lib_cell_renderer_new(); render_cell = lib_cell_renderer_new();
render_lib = lib_cell_renderer_new(); render_lib = lib_cell_renderer_new();
render_vertex_count = cell_statistics_renderer_new();
column = gtk_tree_view_column_new_with_attributes(_("Library"), render_lib, "gds-lib", CELL_SEL_LIBRARY, NULL); column = gtk_tree_view_column_new_with_attributes(_("Library"), render_lib, "gds-lib", CELL_SEL_LIBRARY, NULL);
gtk_tree_view_append_column(self->cell_tree_view, column); gtk_tree_view_append_column(self->cell_tree_view, column);
@@ -246,6 +257,10 @@ int gds_render_gui_setup_cell_selector(GdsRenderGui *self)
"error-level", CELL_SEL_CELL_ERROR_STATE, NULL); "error-level", CELL_SEL_CELL_ERROR_STATE, NULL);
gtk_tree_view_append_column(self->cell_tree_view, column); gtk_tree_view_append_column(self->cell_tree_view, column);
column = gtk_tree_view_column_new_with_attributes(_("Vertex | GFX Count"), render_vertex_count, "cell-stat", CELL_SEL_STAT,
NULL);
gtk_tree_view_append_column(self->cell_tree_view, column);
/* Callback for selection /* Callback for selection
* This prevents selecting a library * This prevents selecting a library
*/ */
@@ -255,6 +270,10 @@ int gds_render_gui_setup_cell_selector(GdsRenderGui *self)
return 0; return 0;
} }
const struct gds_cell_statistics cc = {
.vertex_count = 12,
};
/** /**
* @brief Callback function of Load GDS button * @brief Callback function of Load GDS button
* @param button * @param button
@@ -353,6 +372,7 @@ static void on_load_gds(gpointer button, gpointer user)
CELL_SEL_CELL, gds_c, CELL_SEL_CELL, gds_c,
CELL_SEL_CELL_ERROR_STATE, cell_error_level, CELL_SEL_CELL_ERROR_STATE, cell_error_level,
CELL_SEL_LIBRARY, gds_c->parent_library, CELL_SEL_LIBRARY, gds_c->parent_library,
CELL_SEL_STAT, &gds_c->stats,
-1); -1);
} /* for cells */ } /* for cells */
} /* for libraries */ } /* for libraries */
@@ -652,6 +672,9 @@ static void gds_render_gui_dispose(GObject *gobject)
g_clear_object(&self->save_layer_button); g_clear_object(&self->save_layer_button);
g_clear_object(&self->open_button); g_clear_object(&self->open_button);
g_clear_object(&self->select_all_button); g_clear_object(&self->select_all_button);
#ifdef GDS_RENDER_OPGENGL_PREVIEW
g_clear_object(&self->preview_gui);
#endif
if (self->main_window) { if (self->main_window) {
g_signal_handlers_destroy(self->main_window); g_signal_handlers_destroy(self->main_window);
@@ -755,7 +778,15 @@ static void gds_render_gui_init(GdsRenderGui *self)
GtkWidget *activity_bar_box; GtkWidget *activity_bar_box;
GtkWidget *auto_color_button; GtkWidget *auto_color_button;
GtkWidget *auto_naming_button; GtkWidget *auto_naming_button;
#ifdef GDS_RENDER_OPGENGL_PREVIEW
OpenGlPreviewGui *preview_gui;
preview_gui = opengl_preview_gui_new();
/* No need to reference the preview gui. It is already referenced upon creation */
self->preview_gui = preview_gui;
opengl_preview_gui_show(preview_gui);
#endif
main_builder = gtk_builder_new_from_resource("/gui/main.glade"); main_builder = gtk_builder_new_from_resource("/gui/main.glade");
self->cell_tree_view = GTK_TREE_VIEW(gtk_builder_get_object(main_builder, "cell-tree")); self->cell_tree_view = GTK_TREE_VIEW(gtk_builder_get_object(main_builder, "cell-tree"));

View File

@@ -43,6 +43,7 @@
#include <glib/gi18n.h> #include <glib/gi18n.h>
#include <gds-render/gds-utils/gds-parser.h> #include <gds-render/gds-utils/gds-parser.h>
#include <gds-render/gds-utils/gds-statistics.h>
/** /**
* @brief Default units assumed for library. * @brief Default units assumed for library.
@@ -50,8 +51,8 @@
*/ */
#define GDS_DEFAULT_UNITS (10E-9) #define GDS_DEFAULT_UNITS (10E-9)
#define GDS_ERROR(fmt, ...) printf("[PARSE_ERROR] " fmt "\n", ##__VA_ARGS__) /**< @brief Print GDS error*/ #define GDS_ERROR(fmt, ...) fprintf(stderr, "[PARSE_ERROR] " fmt "\n", ##__VA_ARGS__) /**< @brief Print GDS error*/
#define GDS_WARN(fmt, ...) printf("[PARSE_WARNING] " fmt "\n", ##__VA_ARGS__) /**< @brief Print GDS warning */ #define GDS_WARN(fmt, ...) fprintf(stderr, "[PARSE_WARNING] " fmt "\n", ##__VA_ARGS__) /**< @brief Print GDS warning */
#if GDS_PRINT_DEBUG_INFOS #if GDS_PRINT_DEBUG_INFOS
/**< @brief standard printf. But can be disabled in code. */ /**< @brief standard printf. But can be disabled in code. */
@@ -279,8 +280,13 @@ static GList *append_library(GList *curr_list, const struct gds_library_parsing_
lib->cell_names = NULL; lib->cell_names = NULL;
/* Copy the settings into the library */ /* Copy the settings into the library */
memcpy(&lib->parsing_opts, opts, sizeof(struct gds_library_parsing_opts)); memcpy(&lib->parsing_opts, opts, sizeof(struct gds_library_parsing_opts));
} else lib->stats.cell_count = 0;
lib->stats.gfx_count = 0;
lib->stats.reference_count = 0;
lib->stats.vertex_count = 0;
} else {
return NULL; return NULL;
}
if (library_ptr) if (library_ptr)
*library_ptr = lib; *library_ptr = lib;
@@ -356,6 +362,10 @@ static GList *append_cell(GList *curr_list, struct gds_cell **cell_ptr)
cell->parent_library = NULL; cell->parent_library = NULL;
cell->checks.unresolved_child_count = GDS_CELL_CHECK_NOT_RUN; cell->checks.unresolved_child_count = GDS_CELL_CHECK_NOT_RUN;
cell->checks.affected_by_reference_loop = GDS_CELL_CHECK_NOT_RUN; cell->checks.affected_by_reference_loop = GDS_CELL_CHECK_NOT_RUN;
cell->stats.reference_count = 0;
cell->stats.total_vertex_count = 0;
cell->stats.gfx_count = 0;
cell->stats.vertex_count = 0;
} else } else
return NULL; return NULL;
/* return cell */ /* return cell */
@@ -605,6 +615,15 @@ static void scan_library_references(gpointer library_list_item, gpointer user)
g_list_foreach(lib->cells, scan_cell_references_and_polygons, lib); g_list_foreach(lib->cells, scan_cell_references_and_polygons, lib);
} }
static void calc_library_stats(gpointer library_list_item, gpointer user)
{
struct gds_library *lib = (struct gds_library *)library_list_item;
(void)user;
GDS_INF("Calculating stats for Library: %s\n", lib->name);
gds_statistics_calc_cummulative_counts_in_lib(lib);
}
/** /**
* @brief gds_parse_date * @brief gds_parse_date
* @param buffer Buffer that contains the GDS Date field * @param buffer Buffer that contains the GDS Date field
@@ -686,6 +705,7 @@ static void convert_aref_to_sref(struct gds_cell_array_instance *aref, struct gd
for (row = 0; row < aref->rows; row++) { for (row = 0; row < aref->rows; row++) {
/* Create new instance for this row/column and configure data */ /* Create new instance for this row/column and configure data */
container_cell->child_cells = append_cell_ref(container_cell->child_cells, &sref_inst); container_cell->child_cells = append_cell_ref(container_cell->child_cells, &sref_inst);
container_cell->stats.reference_count++;
if (!sref_inst) { if (!sref_inst) {
GDS_ERROR("Appending cell ref failed!"); GDS_ERROR("Appending cell ref failed!");
continue; continue;
@@ -867,6 +887,7 @@ int parse_gds_from_file(const char *filename, GList **library_list,
} }
current_cell->child_cells = append_cell_ref(current_cell->child_cells, current_cell->child_cells = append_cell_ref(current_cell->child_cells,
&current_s_reference); &current_s_reference);
current_cell->stats.reference_count++;
if (current_cell->child_cells == NULL) { if (current_cell->child_cells == NULL) {
GDS_ERROR("Memory allocation failed"); GDS_ERROR("Memory allocation failed");
run = -4; run = -4;
@@ -896,6 +917,9 @@ int parse_gds_from_file(const char *filename, GList **library_list,
: (current_graphics->gfx_type == GRAPHIC_PATH ? "path" : (current_graphics->gfx_type == GRAPHIC_PATH ? "path"
: "box"))); : "box")));
current_graphics = NULL; current_graphics = NULL;
if (current_cell) {
current_cell->stats.gfx_count++;
}
} }
if (current_s_reference != NULL) { if (current_s_reference != NULL) {
GDS_INF("\tLeaving Reference\n"); GDS_INF("\tLeaving Reference\n");
@@ -1045,7 +1069,9 @@ int parse_gds_from_file(const char *filename, GList **library_list,
current_graphics->vertices = current_graphics->vertices =
append_vertex(current_graphics->vertices, x, y); append_vertex(current_graphics->vertices, x, y);
GDS_INF("\t\tSet coordinate: %d/%d\n", x, y); GDS_INF("\t\tSet coordinate: %d/%d\n", x, y);
if (current_cell) {
current_cell->stats.vertex_count++;
}
} }
} else if (current_a_reference) { } else if (current_a_reference) {
for (i = 0; i < 3; i++) { for (i = 0; i < 3; i++) {
@@ -1161,8 +1187,13 @@ int parse_gds_from_file(const char *filename, GList **library_list,
if (!run) { if (!run) {
/* Iterate and find references to cells */ /* Iterate and find references to cells */
g_list_foreach(lib_list, scan_library_references, NULL); g_list_foreach(lib_list, scan_library_references, NULL);
/* Calculate lib stats and cummulative total counts */
g_list_foreach(lib_list, calc_library_stats, NULL);
} }
*library_list = lib_list; *library_list = lib_list;
free(workbuff); free(workbuff);

View File

@@ -0,0 +1,93 @@
/*
* GDSII-Converter
* Copyright (C) 2018 Mario Hüttel <mario.huettel@gmx.net>
*
* This file is part of GDSII-Converter.
*
* GDSII-Converter is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2 as
* published by the Free Software Foundation.
*
* GDSII-Converter is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with GDSII-Converter. If not, see <http://www.gnu.org/licenses/>.
*/
/**
* @file gds-statistics.c
* @brief Statistics of GDS files
* @author Mario Hüttel <mario.huettel@gmx.net>
*
*/
#include <gds-render/gds-utils/gds-statistics.h>
#include <stdio.h>
/**
* @addtogroup GDS-Utilities
* @{
*/
#define MAX_RECURSION_DEPTH (1024)
static void calculate_vertex_gfx_count_cell(struct gds_cell *cell, unsigned int recursion_depth)
{
GList *cell_iter;
struct gds_cell_instance *cell_ref;
struct gds_cell *sub_cell;
g_return_if_fail(cell);
/* Check if cell has already been calculated */
if (cell->stats.total_gfx_count && cell->stats.total_vertex_count) {
/* Return. This cell and all of its subcells have been calculated */
return;
}
/* Update with own vertex / GFX count */
cell->stats.total_vertex_count = cell->stats.vertex_count;
cell->stats.total_gfx_count = cell->stats.gfx_count;
/* Do not analyze further, if maximum recursion depth is reached */
if (!recursion_depth)
return;
for (cell_iter = cell->child_cells; cell_iter; cell_iter = g_list_next(cell_iter)) {
/* Scan all subcells recursively, if there are any */
cell_ref = (struct gds_cell_instance *)cell_iter->data;
sub_cell = (struct gds_cell *)cell_ref->cell_ref;
calculate_vertex_gfx_count_cell(sub_cell, recursion_depth - 1);
/* Increment count */
cell->stats.total_vertex_count += sub_cell->stats.total_vertex_count;
cell->stats.total_gfx_count += sub_cell->stats.total_vertex_count;
}
}
void gds_statistics_calc_cummulative_counts_in_lib(struct gds_library *lib)
{
GList *cell_iter;
struct gds_cell *cell;
g_return_if_fail(lib);
for (cell_iter = lib->cells; cell_iter; cell_iter = g_list_next(cell_iter)) {
cell = (struct gds_cell *)cell_iter->data;
calculate_vertex_gfx_count_cell(cell, MAX_RECURSION_DEPTH);
lib->stats.vertex_count += cell->stats.vertex_count;
lib->stats.cell_count++;
lib->stats.gfx_count += cell->stats.gfx_count;
lib->stats.reference_count += cell->stats.reference_count;
}
}
/** @} */

View File

@@ -0,0 +1,56 @@
/*
* GDSII-Converter
* Copyright (C) 2022 Mario Hüttel <mario.huettel@gmx.net>
*
* This file is part of GDSII-Converter.
*
* GDSII-Converter is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2 as
* published by the Free Software Foundation.
*
* GDSII-Converter is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with GDSII-Converter. If not, see <http://www.gnu.org/licenses/>.
*/
/**
* @file cell-statistics-renderer.h
* @brief Header file for the CellStatisticsRenderer GObject Class
* @author Mario Hüttel <mario.huettel@gmx.net>
*/
/**
* @addtogroup CellStatisticsRenderer
* @{
*/
#ifndef _CELL_STATISTICS_RENDERER_H_
#define _CELL_STATISTICS_RENDERER_H_
#include <gtk/gtk.h>
#include <gds-render/gds-utils/gds-statistics.h>
G_BEGIN_DECLS
G_DECLARE_FINAL_TYPE(CellStatisticsRenderer, cell_statistics_renderer, GDS_RENDER, CELL_STAT_RENDERER, GtkCellRendererText)
#define TYPE_GDS_RENDER_CELL_STAT_RENDERER (cell_statistics_renderer_get_type())
typedef struct _CellStatisticsRenderer {
GtkCellRendererText super;
} CellStatisticsRenderer;
/**
* @brief New Cell statistics renderer
* @return GObject
*/
GtkCellRenderer *cell_statistics_renderer_new(void);
G_END_DECLS
#endif /* _CELL_STATISTICS_RENDERER_H_ */
/** @} */

View File

@@ -71,6 +71,14 @@ int command_line_convert_gds(const char *gds_name,
gboolean tex_layers, gboolean tex_layers,
double scale); double scale);
/**
* @brief Analyze the given GDS file
* @param format Output format of the analysis result
* @param gds_name GDS file name
* @return 0 if successful
*/
int command_line_analyze_lib(const char *format, const char *gds_name);
#endif /* _COMMAND_LINE_H_ */ #endif /* _COMMAND_LINE_H_ */
/** @} */ /** @} */

View File

@@ -0,0 +1,42 @@
/*
* GDSII-Converter
* Copyright (C) 2018 Mario Hüttel <mario.huettel@gmx.net>
*
* This file is part of GDSII-Converter.
*
* GDSII-Converter is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2 as
* published by the Free Software Foundation.
*
* GDSII-Converter is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with GDSII-Converter. If not, see <http://www.gnu.org/licenses/>.
*/
/**
* @file gds-parser.h
* @brief Header file for the GDS statistics
* @author Mario Hüttel <mario.huettel@gmx.net>
*/
#ifndef _GDS_STATISTICS_H_
#define _GDS_STATISTICS_H_
/**
* @addtogroup GDS-Utilities
* @{
*/
#include <glib.h>
#include <gds-render/gds-utils/gds-types.h>
void gds_statistics_calc_cummulative_counts_in_lib(struct gds_library *lib);
/** @} */
#endif /* _GDS_STATISTICS_H_ */

View File

@@ -65,6 +65,22 @@ struct gds_point {
int y; int y;
}; };
struct gds_cell_statistics {
size_t gfx_count;
size_t vertex_count;
size_t total_vertex_count;
size_t total_gfx_count;
size_t reference_count;
};
struct gds_lib_statistics {
size_t gfx_count;
size_t vertex_count;
size_t reference_count;
size_t cell_count;
};
/** /**
* @brief Stores the result of the cell checks. * @brief Stores the result of the cell checks.
*/ */
@@ -127,6 +143,7 @@ struct gds_cell {
GList *graphic_objs; /**< @brief List of #gds_graphics */ GList *graphic_objs; /**< @brief List of #gds_graphics */
struct gds_library *parent_library; /**< @brief Pointer to parent library */ struct gds_library *parent_library; /**< @brief Pointer to parent library */
struct gds_cell_checks checks; /**< @brief Checking results */ struct gds_cell_checks checks; /**< @brief Checking results */
struct gds_cell_statistics stats; /**< @brief Optional statistic info */
}; };
/** /**
@@ -147,8 +164,10 @@ struct gds_library {
double unit_in_meters; /**< Length of a database unit in meters */ double unit_in_meters; /**< Length of a database unit in meters */
GList *cells; /**< List of #gds_cell that contains all cells in this library*/ GList *cells; /**< List of #gds_cell that contains all cells in this library*/
GList *cell_names /**< List of strings that contains all cell names */; GList *cell_names /**< List of strings that contains all cell names */;
struct gds_lib_statistics stats;
}; };
/** @} */ /** @} */
#endif /* __GDS_TYPES_H__ */ #endif /* __GDS_TYPES_H__ */

14
main.c
View File

@@ -96,6 +96,11 @@ static void app_about(GSimpleAction *action, GVariant *parameter, gpointer user_
comment_text = g_string_new(_("gds-render is a free tool for rendering GDS2 layout files into vector graphics.")); comment_text = g_string_new(_("gds-render is a free tool for rendering GDS2 layout files into vector graphics."));
g_string_append_printf(comment_text, _("\n\nFull git commit: %s"), _app_git_commit); g_string_append_printf(comment_text, _("\n\nFull git commit: %s"), _app_git_commit);
#ifdef GDS_RENDER_OPGENGL_PREVIEW
g_string_append_printf(comment_text, _("\nOpenGL Previev: Availabe"));
#else
g_string_append_printf(comment_text, _("\nOpenGL Previev: Unavailabe"));
#endif
builder = gtk_builder_new_from_resource("/gui/about.glade"); builder = gtk_builder_new_from_resource("/gui/about.glade");
dialog = GTK_DIALOG(gtk_builder_get_object(builder, "about-dialog")); dialog = GTK_DIALOG(gtk_builder_get_object(builder, "about-dialog"));
gtk_window_set_transient_for(GTK_WINDOW(dialog), NULL); gtk_window_set_transient_for(GTK_WINDOW(dialog), NULL);
@@ -262,6 +267,8 @@ int main(int argc, char **argv)
gchar *cellname = NULL; gchar *cellname = NULL;
gchar **renderer_args = NULL; gchar **renderer_args = NULL;
gboolean version = FALSE, pdf_standalone = FALSE, pdf_layers = FALSE; gboolean version = FALSE, pdf_standalone = FALSE, pdf_layers = FALSE;
gboolean analyze = FALSE;
gchar *format = NULL;
int scale = 1000; int scale = 1000;
int app_status = 0; int app_status = 0;
struct external_renderer_params so_render_params; struct external_renderer_params so_render_params;
@@ -275,6 +282,8 @@ int main(int argc, char **argv)
GOptionEntry entries[] = { GOptionEntry entries[] = {
{"version", 'v', 0, G_OPTION_ARG_NONE, &version, _("Print version"), NULL}, {"version", 'v', 0, G_OPTION_ARG_NONE, &version, _("Print version"), NULL},
{"analyze", 'A', 0, G_OPTION_ARG_NONE, &analyze, _("Anaylze GDS file"), NULL},
{"format", 'f', 0, G_OPTION_ARG_STRING, &format, _("Output format of analysis result, Default simple"), "[simple | pretty | cellsonly]"},
{"renderer", 'r', 0, G_OPTION_ARG_STRING_ARRAY, &renderer_args, {"renderer", 'r', 0, G_OPTION_ARG_STRING_ARRAY, &renderer_args,
_("Renderer to use. Can be used multiple times."), "pdf|svg|tikz|ext"}, _("Renderer to use. Can be used multiple times."), "pdf|svg|tikz|ext"},
{"scale", 's', 0, G_OPTION_ARG_INT, &scale, _("Divide output coordinates by <SCALE>"), "<SCALE>" }, {"scale", 's', 0, G_OPTION_ARG_INT, &scale, _("Divide output coordinates by <SCALE>"), "<SCALE>" },
@@ -320,10 +329,13 @@ int main(int argc, char **argv)
for (i = 2; i < argc; i++) for (i = 2; i < argc; i++)
printf(_("Ignored argument: %s"), argv[i]); printf(_("Ignored argument: %s"), argv[i]);
if (analyze) {
app_status = command_line_analyze_lib(format, gds_name);
} else {
app_status = app_status =
command_line_convert_gds(gds_name, cellname, renderer_args, output_paths, mappingname, command_line_convert_gds(gds_name, cellname, renderer_args, output_paths, mappingname,
&so_render_params, pdf_standalone, pdf_layers, scale); &so_render_params, pdf_standalone, pdf_layers, scale);
}
} else { } else {
app_status = start_gui(argc, argv); app_status = start_gui(argc, argv);
} }

View File

@@ -1,2 +1,3 @@
add_subdirectory(plugin-example) add_subdirectory(plugin-example)
add_custom_target(plugins DEPENDS pluginexample) add_custom_target(plugins DEPENDS pluginexample)
cmake_minimum_required(VERSION 3.0)

View File

@@ -1,5 +1,5 @@
project(pluginexample) project(pluginexample)
cmake_minimum_required(VERSION 2.8) cmake_minimum_required(VERSION 3.0)
find_package(PkgConfig REQUIRED) find_package(PkgConfig REQUIRED)
pkg_search_module(PYTHON REQUIRED python3) pkg_search_module(PYTHON REQUIRED python3)

View File

@@ -0,0 +1,18 @@
project(opengl-preview)
cmake_minimum_required(VERSION 3.0)
find_package(PkgConfig REQUIRED)
pkg_check_modules(EPOXY REQUIRED epoxy)
pkg_search_module(GLIB REQUIRED glib-2.0)
pkg_check_modules(GTK3 REQUIRED gtk+-3.0)
aux_source_directory("src" SRCS)
add_subdirectory(poly2tri-wrapper)
add_library(${PROJECT_NAME} STATIC ${SRCS})
target_include_directories(${PROJECT_NAME} PUBLIC "include")
target_include_directories(${PROJECT_NAME} PRIVATE ${EPOXY_INCLUDE_DIRS} ${GLIB_INCLUDE_DIRS} ${GTK3_INCLUDE_DIRS})
target_link_directories(${PROJECT_NAME} PUBLIC ${EPOXY_LINK_DIRS} ${GLIB_LINK_DIRS} ${GTK3_LINK_DIRS})
target_link_libraries(${PROJECT_NAME} ${GLIB_LDFLAGS} ${EPOXY_LDFLAGS} ${GTK3_LDFLAGS} poly2tri-wrapper)

View File

@@ -0,0 +1,14 @@
#ifndef _PREVIEW_RENDERING_GUI_H_
#define _PREVIEW_RENDERING_GUI_H_
#include <gtk/gtk.h>
G_DECLARE_FINAL_TYPE(OpenGlPreviewGui, opengl_preview_gui, GDS_RENDER, OPENGL_PREVIEW_GUI, GObject)
#define TYPE_GDS_RENDER_OPENGL_PREVIEW_GUI (opengl_preview_gui_get_type())
OpenGlPreviewGui *opengl_preview_gui_new(void);
void opengl_preview_gui_show(OpenGlPreviewGui *self);
#endif /* _PREVIEW_RENDERING_GUI_H_ */

View File

@@ -0,0 +1,11 @@
project(poly2tri-wrapper LANGUAGES CXX)
cmake_minimum_required(VERSION 3.12)
add_subdirectory(../../3rdparty/poly2tri poly2tri)
set(CMAKE_CXX_STANDARD 14)
aux_source_directory("src" WRAPPER_SOURCES)
add_library(${PROJECT_NAME} STATIC ${WRAPPER_SOURCES})
target_link_libraries(${PROJECT_NAME} poly2tri)
target_include_directories(${PROJECT_NAME} PUBLIC "include")

View File

@@ -0,0 +1,16 @@
#ifndef _POLY2TRI_WRAPPER_H_
#define _POLY2TRI_WRAPPER_H_
#ifdef __cplusplus
extern "C" {
#endif
#include <gds-render/gds-utils/gds-types.h>
int tesselator_triangulate_polygon(const struct gds_graphics *gfx, double scale, float **output_vertices, size_t *vertex_count);
#ifdef __cplusplus
} /* extern "C" */
#endif
#endif /* _POLY2TRI_WRAPPER_H_ */

View File

@@ -0,0 +1,132 @@
#include <iostream>
#include <poly2tri/poly2tri.h>
#include <poly2tri-wrapper/poly2tri-wrapper.h>
//#include <gds-render/gds-utils/gds-types.h>
#include <vector>
class Hole {
private:
std::vector <p2t::Point *> hole_vertices;
public:
const std::vector <p2t::Point *> &get_vertices()
{
return hole_vertices;
}
void add_vertex(const p2t::Point &point)
{
auto pt = new p2t::Point(point);
hole_vertices.push_back(pt);
}
Hole(std::vector<p2t::Point *>::iterator start, std::vector<p2t::Point *>::iterator end)
{
hole_vertices = std::vector<p2t::Point *>(start, end);
}
};
static std::vector<Hole> resolve_holes_in_polyline(std::vector<p2t::Point *> &polyline)
{
bool found = false;
std::vector<Hole> holes;
std::vector<std::pair<
std::vector<p2t::Point *>::iterator,
std::vector<p2t::Point *>::iterator>
> points_to_remove;
for (auto start_it = polyline.begin(); start_it != polyline.end(); start_it++) {
for (auto check_it = std::next(start_it); check_it != polyline.end(); check_it++) {
/* Check if points are equal */
if (**start_it == **check_it) {
if (**std::prev(check_it) == **std::next(start_it)) {
/* Found a hole. Everything between start_it and check_it can be removed */
auto hole = Hole(std::next(start_it)+1, check_it);
holes.push_back(hole);
auto tbd = std::make_pair(start_it, check_it);
points_to_remove.push_back(tbd);
found = true;
break;
}
}
}
if (found)
break;
}
/* Remove form polyline */
for (auto it_pair_it = points_to_remove.begin(); it_pair_it != points_to_remove.end(); it_pair_it++) {
auto it_pair = *it_pair_it;
delete *it_pair.first;
delete *std::next(it_pair.first);
polyline.erase(it_pair.first, it_pair.second);
}
if (found) {
auto new_holes = resolve_holes_in_polyline(polyline);
holes.insert(holes.end(), new_holes.begin(), new_holes.end());
}
return holes;
}
int tesselator_triangulate_polygon(const struct gds_graphics *gfx, double scale, float** output_vertices, size_t *vertex_count)
{
GList *vertex_iter;
std::vector<p2t::Point*> polyline;
if (gfx->gfx_type != GRAPHIC_POLYGON)
return -1;
for (vertex_iter = gfx->vertices; vertex_iter; vertex_iter = g_list_next(vertex_iter)) {
struct gds_point *gds_pt = (struct gds_point *)vertex_iter->data;
auto pt = new p2t::Point((double)gds_pt->x/scale, (double)gds_pt->y/scale);
polyline.push_back(pt);
}
auto holes = resolve_holes_in_polyline(polyline);
auto my_cdt = p2t::CDT(polyline);
for (auto hole_it = holes.begin(); hole_it != holes.end(); hole_it++) {
my_cdt.AddHole((*hole_it).get_vertices());
}
my_cdt.Triangulate();
auto triangles = my_cdt.GetTriangles();
/* Free the triangles */
for (auto it = triangles.begin(); it != triangles.end(); it++) {
auto triangle = *it;
std::cout << "Triangle: " <<
triangle->GetPoint(0)->x << "|" << triangle->GetPoint(0)->y << ","
<< triangle->GetPoint(1)->x << "|" << triangle->GetPoint(1)->x << ","
<< triangle->GetPoint(2)->x << "|" << triangle->GetPoint(2)->y
<< std::endl;
}
/* Get the amount of triangles */
auto count = triangles.size();
*output_vertices = (float *)malloc(2*sizeof(float)*3*count);
*vertex_count = count * 3;
/* Free the points in the vector */
for (unsigned int i = 0; i < count; i++) {
for (int j = 0; j < 3; j++) {
auto pt = triangles[i]->GetPoint(j);
unsigned int idx = i * 6 + j * 2;
(*output_vertices)[idx] = (float)pt->x;
(*output_vertices)[idx + 1] = (float)pt->y;
}
}
for (auto it = polyline.begin(); it != polyline.end(); it++)
delete *it;
return 0;
}

View File

@@ -0,0 +1,258 @@
#include <preview-rendering/preview-rendering-gui.h>
#include <poly2tri-wrapper/poly2tri-wrapper.h>
#include <epoxy/gl.h>
struct _OpenGlPreviewGui {
GObject super;
GtkWindow *main_window;
GtkGLArea *gl_area;
unsigned int polygon_shader_prog;
unsigned int vao;
unsigned int vao_vertex_count;
unsigned int vbo;
float color[4];
gboolean line;
};
G_DEFINE_TYPE(OpenGlPreviewGui, opengl_preview_gui, G_TYPE_OBJECT)
static void opengl_preview_gui_dispose(GObject *gobj)
{
OpenGlPreviewGui *self;
self = GDS_RENDER_OPENGL_PREVIEW_GUI(gobj);
g_clear_object(&self->gl_area);
if (self->main_window) {
gtk_widget_destroy(GTK_WIDGET(self->main_window));
self->main_window = NULL;
}
G_OBJECT_CLASS(opengl_preview_gui_parent_class)->dispose(gobj);
}
static void opengl_preview_gui_class_init(OpenGlPreviewGuiClass *klass)
{
GObjectClass *oclass = G_OBJECT_CLASS(klass);
oclass->dispose = opengl_preview_gui_dispose;
}
static gboolean gl_area_render(GtkGLArea *area, GdkGLContext *context, gpointer user)
{
OpenGlPreviewGui *gui;
int loc;
gui = GDS_RENDER_OPENGL_PREVIEW_GUI(user);
gtk_gl_area_make_current(area);
glClearColor (0, 0, 0, 1.0);
glClear (GL_COLOR_BUFFER_BIT);
glPolygonMode(GL_FRONT_AND_BACK, gui->line ? GL_LINE : GL_FILL);
glUseProgram(gui->polygon_shader_prog);
glBindVertexArray(gui->vao);
loc = glGetUniformLocation(gui->polygon_shader_prog, "const_color");
glUniform4fv(loc, 1, gui->color);
glDrawArrays(GL_TRIANGLES, 0, gui->vao_vertex_count);
glFlush();
return TRUE;
}
static int compile_shader_from_resource(GLenum shader_type, const char *res_name, unsigned int *shader)
{
int success;
GBytes *res_bytes;
const char *data;
gsize size;
int size_int;
int sh;
res_bytes = g_resources_lookup_data(res_name, G_RESOURCE_LOOKUP_FLAGS_NONE, NULL);
data = g_bytes_get_data(res_bytes, &size);
sh = glCreateShader(shader_type);
size_int = (int)size;
glShaderSource(sh, 1, &data, &size_int);
glCompileShader(sh);
glGetShaderiv(sh, GL_COMPILE_STATUS, &success);
g_bytes_unref(res_bytes);
if (shader)
*shader = sh;
return success;
}
static gboolean gl_area_realize(GtkGLArea *area, gpointer user)
{
unsigned int vbo;
unsigned int vs;
unsigned int fs;
unsigned int prog;
unsigned int vao;
OpenGlPreviewGui *gui;
int success;
struct gds_graphics gfx;
struct gds_point points[20];
size_t vertex_count;
gui = GDS_RENDER_OPENGL_PREVIEW_GUI(user);
gui->color[0] = 0.6f;
gui->color[1] = 0.5f;
gui->color[2] = 0.12f;
gui->color[3] = 1.0f;
gtk_gl_area_make_current(area);
if (!compile_shader_from_resource(GL_VERTEX_SHADER, "/shaders/polygon.vs", &vs)) {
g_warning("Error compiling vertex shader");
}
if (!compile_shader_from_resource(GL_FRAGMENT_SHADER, "/shaders/polygon.fs", &fs)) {
g_warning("Error compiling fragment shader");
}
prog = glCreateProgram();
glAttachShader(prog, vs);
glAttachShader(prog, fs);
glLinkProgram(prog);
glGetProgramiv(prog, GL_LINK_STATUS, &success);
if (!success) {
g_warning("Error linking shader");
}
glUseProgram(prog);
glDeleteShader(vs);
glDeleteShader(fs);
gui->polygon_shader_prog = prog;
gfx.vertices = NULL;
points[0].x = -100;
points[0].y = -100;
points[1].x = -100;
points[1].y = +100;
points[2].x = +0;
points[2].y = +100;
points[3].x = +0;
points[3].y = 20;
points[4].x = -20;
points[4].y = 20;
points[5].x = -20;
points[5].y = -20;
points[6].x = 20;
points[6].y = -20;
points[7].x = 20;
points[7].y = 20;
points[8].x = 0;
points[8].y = 20;
points[9].x = 0;
points[9].y = 100;
points[10].x = 100;
points[10].y = 100;
points[11].x = 100;
points[11].y = 5;
points[12].x = 60;
points[12].y = 5;
points[13].x = 60;
points[13].y = 20;
points[14].x = 50;
points[14].y = 20;
points[15].x = 50;
points[15].y = 0;
points[16].x = 60;
points[16].y = 0;
points[17].x = 60;
points[17].y = 5;
points[18].x = 100;
points[18].y = 5;
points[19].x = 100;
points[19].y = -100;
gfx.gfx_type = GRAPHIC_POLYGON;
for (int i = 0; i < 20; i++) {
gfx.vertices = g_list_append(gfx.vertices, &points[i]);
}
float *vertices = NULL;
tesselator_triangulate_polygon(&gfx, 180.0, &vertices, &vertex_count);
gui->vao_vertex_count = vertex_count;
glGenVertexArrays(1, &vao);
glBindVertexArray(vao);
glGenBuffers(1, &vbo);
glBindBuffer(GL_ARRAY_BUFFER, vbo);
glBufferData(GL_ARRAY_BUFFER, vertex_count*2*sizeof(float), vertices, GL_STATIC_DRAW);
glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 2*sizeof(float), (void *)0);
glEnableVertexAttribArray(0);
free(vertices);
gui->vao = vao;
gui->vbo = vbo;
g_list_free(gfx.vertices);
return TRUE;
}
static void on_clicked(GtkWidget *sender, gboolean *p)
{
*p = !*p;
}
static void opengl_preview_gui_init(OpenGlPreviewGui *self)
{
GtkBuilder *builder;
builder = gtk_builder_new_from_resource("/gui/preview-window.glade");
self->main_window = GTK_WINDOW(gtk_builder_get_object(builder, "main-window"));
self->gl_area = GTK_GL_AREA(gtk_builder_get_object(builder, "gl-area"));
g_signal_connect(self->gl_area, "render", G_CALLBACK(gl_area_render), self);
g_signal_connect(self->gl_area, "realize", G_CALLBACK(gl_area_realize), self);
g_signal_connect(gtk_builder_get_object(builder, "test-button"), "clicked", G_CALLBACK(on_clicked), &self->line);
self->line = FALSE;
g_object_ref(self->gl_area);
}
OpenGlPreviewGui *opengl_preview_gui_new(void)
{
return GDS_RENDER_OPENGL_PREVIEW_GUI(g_object_new(TYPE_GDS_RENDER_OPENGL_PREVIEW_GUI, NULL));
}
void opengl_preview_gui_show(OpenGlPreviewGui *self)
{
gtk_widget_show(GTK_WIDGET(self->main_window));
}

View File

@@ -0,0 +1,8 @@
#include <epoxy/gl.h>
int foobar(void)
{
GLuint foo;
glGenBuffers(1, &foo);
return 42;
}

View File

@@ -0,0 +1,43 @@
<?xml version="1.0" encoding="UTF-8"?>
<!-- Generated with glade 3.38.2 -->
<interface>
<requires lib="gtk+" version="3.24"/>
<object class="GtkWindow" id="main-window">
<property name="can-focus">False</property>
<property name="default-width">1024</property>
<property name="default-height">500</property>
<child>
<object class="GtkBox">
<property name="visible">True</property>
<property name="can-focus">False</property>
<property name="baseline-position">bottom</property>
<child>
<object class="GtkButton" id="test-button">
<property name="label" translatable="yes">button</property>
<property name="visible">True</property>
<property name="can-focus">True</property>
<property name="receives-default">True</property>
</object>
<packing>
<property name="expand">False</property>
<property name="fill">True</property>
<property name="position">0</property>
</packing>
</child>
<child>
<object class="GtkGLArea" id="gl-area">
<property name="visible">True</property>
<property name="app-paintable">True</property>
<property name="can-focus">False</property>
<property name="has-alpha">True</property>
</object>
<packing>
<property name="expand">True</property>
<property name="fill">True</property>
<property name="position">1</property>
</packing>
</child>
</object>
</child>
</object>
</interface>

View File

@@ -5,6 +5,7 @@
<file compressed="true">about.glade</file> <file compressed="true">about.glade</file>
<file>layer-widget.glade</file> <file>layer-widget.glade</file>
<file>dialog.glade</file> <file>dialog.glade</file>
<file compressed="true">preview-window.glade</file>
</gresource> </gresource>
<gresource prefix="/data"> <gresource prefix="/data">
<file compressed="true">color-palette.txt</file> <file compressed="true">color-palette.txt</file>
@@ -12,6 +13,10 @@
<gresource prefix="/images"> <gresource prefix="/images">
<file compressed="true" alias="logo.svg">../icon/gds-render.svg</file> <file compressed="true" alias="logo.svg">../icon/gds-render.svg</file>
</gresource> </gresource>
<gresource prefix="/shaders">
<file compressed="true" alias="polygon.fs">./shaders/polygon.fs.glsl</file>
<file compressed="true" alias="polygon.vs">./shaders/polygon.vs.glsl</file>
</gresource>
</gresources> </gresources>

View File

@@ -0,0 +1,9 @@
#version 330 core
out vec4 FragColor;
in vec4 vertex_color;
void main()
{
FragColor = vertex_color;
}

View File

@@ -0,0 +1,12 @@
#version 330 core
//uniform mat4 mvp;
uniform vec4 const_color;
layout (location = 0) in vec2 input_vertex;
out vec4 vertex_color;
void main()
{
gl_Position = vec4(input_vertex.x, input_vertex.y, 0.0, 1.0);
vertex_color = const_color;
}

View File

@@ -1,4 +1,5 @@
project(gds-render-test) project(gds-render-test)
cmake_minimum_required(VERSION 3.0)
add_custom_target(test "${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}" "-r compact" "-s" DEPENDS ${PROJECT_NAME}) add_custom_target(test "${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}" "-r compact" "-s" DEPENDS ${PROJECT_NAME})
@@ -22,7 +23,6 @@ if(NOT WIN32)
set(BoldWhite "${Esc}[1;37m") set(BoldWhite "${Esc}[1;37m")
endif() endif()
cmake_minimum_required(VERSION 2.8)
find_package(PkgConfig REQUIRED) find_package(PkgConfig REQUIRED)
include_directories("${CMAKE_CURRENT_SOURCE_DIR}/catch-framework") include_directories("${CMAKE_CURRENT_SOURCE_DIR}/catch-framework")