void build(utymap::meshing::Polygon& polygon)
{
ClipperLib::ClipperOffset offset;
ClipperLib::Path path;
path.reserve(polygon.points.size() / 2);
auto lastPointIndex = polygon.points.size() - 2;
double min = std::numeric_limits<double>::max();
for (std::size_t i = 0; i < polygon.points.size(); i += 2) {
auto nextIndex = i == lastPointIndex ? 0 : i + 2;
utymap::meshing::Vector2 v1(polygon.points[i], polygon.points[i + 1]);
utymap::meshing::Vector2 v2(polygon.points[nextIndex], polygon.points[nextIndex + 1]);
min = std::min(min, utymap::meshing::Vector2::distance(v1, v2));
path.push_back(ClipperLib::IntPoint(static_cast<ClipperLib::cInt>(v1.x * Scale),
static_cast<ClipperLib::cInt>(v1.y * Scale)));
}
offset.AddPath(path, ClipperLib::JoinType::jtMiter, ClipperLib::EndType::etClosedPolygon);
ClipperLib::Paths solution;
// NOTE: use minimal side value as reference for offsetting.
offset.Execute(solution, -(min / 10) * Scale);
// NOTE: this is unexpected result for algorithm below, fallback to flat roof.
if (solution.size() != 1 || solution[0].size() != path.size()) {
return FlatRoofBuilder::build(polygon);
}
buildMansardShape(polygon, solution[0], findFirstIndex(solution[0][0], polygon));
}
int main(int argc , char *argv[])
{
int socket_desc , client_sock , c ,*index , mainServerPort = 8852;
struct sockaddr_in server , client , mainServer;
struct arg_struct *args;
int lastPos;
if( argc != 3 )
{
printf("Argument no match\n");
exit(0);
}
initialize();
//create mainServer socket
MainServerSock = socket(AF_INET , SOCK_STREAM , 0);
if (MainServerSock == -1)
{
printf("Could not create socket for mainserver");
}
mainServer.sin_addr.s_addr = inet_addr(argv[1]);
mainServer.sin_family = AF_INET;
sscanf(argv[2],"%d",&mainServerPort);
mainServer.sin_port = htons( mainServerPort );
//Connect to remote server
if (connect(MainServerSock , (struct sockaddr *)&mainServer , sizeof(mainServer)) < 0)
{
perror("connect mainserver failed. Error");
return 1;
}
pthread_t mainServer_send_thread ;
pthread_attr_t mainServer_send_attr ;
pthread_attr_init( & mainServer_send_attr ) ;
pthread_create( & mainServer_send_thread, & mainServer_send_attr, sendToMainServer, NULL ) ;
pthread_t mainServer_recieve_thread ;
pthread_attr_t mainServer_recieve_attr ;
pthread_attr_init( & mainServer_recieve_attr ) ;
pthread_create( & mainServer_recieve_thread, & mainServer_recieve_attr, recieveFromMainServer, NULL ) ;
//end mainServer socket
//Create client socket
socket_desc = socket(AF_INET , SOCK_STREAM , 0);
if (socket_desc == -1)
{
printf("Could not create socket");
}
puts("Socket created");
//Prepare the sockaddr_in structure
/// welcoming socket
server.sin_family = AF_INET;
server.sin_addr.s_addr = INADDR_ANY;
server.sin_port = htons( 24251 );
//Bind
if( bind(socket_desc,(struct sockaddr *)&server , sizeof(server)) < 0)
{
//print the error message
perror("bind failed. Error");
return 1;
}
puts("bind done");
//Listen
listen(socket_desc , (MAX_CLIENT_QUEUE > SOMAXCONN ? SOMAXCONN : MAX_CLIENT_QUEUE ) );
//Accept and incoming connection
puts("Waiting for incoming connections...");
c = sizeof(struct sockaddr_in);
while( (client_sock = accept(socket_desc, (struct sockaddr *)&client, (socklen_t*)&c)) )
{
puts("Connection accepted");
pthread_t sniffer_thread;
lastPos = findFirstIndex();
if( lastPos == -1 )
{
puts("sorry! server is busy :D ");
continue;
}
//
clients[lastPos].socket = client_sock;
args = malloc(sizeof(struct arg_struct));
args->socket = client_sock;
args->index = lastPos;
if( pthread_create( &sniffer_thread , NULL , connection_handler , (void*) args) < 0)
{
perror("could not create thread for connection");
return 1;
}
pthread_t showMessage;
index = malloc(sizeof(int));
*index = lastPos;
if( pthread_create( &showMessage , NULL , outputEach5Second , (void*) index) < 0)
{
perror("could not create thread for show message");
return 1;
}
//Now join the thread , so that we dont terminate before the thread
//pthread_join( sniffer_thread , NULL);
puts("Handlers assigned");
}
if (client_sock < 0)
{
perror("accept failed");
return 1;
}
return 0;
}
