Success!

Note

Error

Session expiration Your session is going to expireClick here to extend

Budget:

Small project <800

Posted on

9/13/17 3:56 PM

Buyer:

116***

This project has expired

Why don't you register anyway? We are sure that you will find many similar projects out of the thousands waiting for you!

Post similar project now

Description

De 2 onderstaande opdrachten moeten worden uitgewerkt met het programma visual studio. Graag wil ik de main.c files.

1. Bit-manipulatie (Bresenham)

In deze opdracht gaat het over een software onderdeel dat onder printer-fabrikanten bekend is als een Raster Image Processor (RIP). Een RIP is verantwoordelijk voor het omzetten van tekenopdrachten, b.v. een lijn of cirkel, in een binaire bitmap. Een binaire bitmap is een compacte representatie van pixels (bits) in computer words. Het is b.v. mogelijk om in één int in totaal 32 pixels te ‘packen’.

In een serie van 6 deelopdrachten pakken we dit vraagstuk aan.

1.1. Als eerste dient een bitmap gemaakt te worden. Deze bestaat uit een array van 32 int’s, die ieder op hun beurt 32 pixels (bits) bevatten. XY-assen dienen zo gekozen te worden dat de X-as in de array-richting loopt en de Y-as in de richting van de bits binnen één woord.

Verder dient daarna de functie p() te worden geschreven die de bitmap uitprint op het console, kies daarbij een ‘.’ voor een 0 en een ’#’ voor een 1-bit.

1.2. Schrijf een functie plt(x,y) die een 1 pixel zet (dus een ‘1’ bit) in de bitmap op positie (x,y).

1.3. Schrijf een functie hl(x0,x1,y) die een 1 pixel brede horizontale lijn tekent in de bitmap. De eerste call van een horizontale lijn is hl(1,5,2); van 1 naar 5 op de y==2 hoogte over een lengte van 5 pixels.

1.4. Schrijf een functie vl(x0,x1,y) die een 1 pixel brede horizontale lijn tekent in de bitmap. De eerste call van een verticale lijn is vl(2,4,7) ); van 2 naar 4 op de x==7 verticaal over een lengte van 3 pixels.

1.5. Er dient nu een functie bh() te worden geschreven die een flauw verlopende lijn tekent van (x1,y1) naar (x2,y2), waarin x2>x1 en y2>y1. Flauw verlopend betekent dat de coordinaten altijd zo gekozen worden dat de richtingscoefficient van de lijn altijd <= 1. De te implementeren functie is ook wel bekend onder de naam Bresenham, de uitvinder van dit algoritme. Je kunt achtergronden vinden op https://en.wikipedia.org/wiki/Bresenham%27s_line_algorithm. Hier staat een algoritme in pseudo code, dat moet je dus omzetten naar C. De call voor deze functie luidt: bh(3,3,12,8), een lijn ter lengte van 10 pixels.

1.6. Als laatste dient er een functie ci() te worden geschreven die een cirkel tekent met middelpunt(x,y) en straal R. De te implementeren functie is ook wel bekend onder de naam “mid point” algoritme, achtergronden kun je vinden op https://en.wikipedia.org/wiki/Midpoint_circle_algorithm.

Hier staat reeds een algoritme in C code. De call voor deze functie luidt: ci(15,15,15), een cirkel op (15,15) met een straal van 15 pixels.

2. Een binaire boom.

In deze opdracht gaan we aan de slag met binaire bomen . Een binaire boom is een boom waarvan elke knoop hoogstens twee kinderen heeft.

Afbeelding 1 Een binaire boom

Als we een binaire boom vertalen naar een datastructuur dan ziet dit als volgt uit:

Elke knoop (A, B, C, …, H in afbeelding 1) heeft een waarde en twee link-velden. Een link-veld “links” dat wijst naar de linker zoon en een link-veld “rechts” dat wijst naar de rechter zoon.

2.1. Ontwerp (in de vorm van een activity diagram) en schrijf een functie maak_boom die uit een array van data uit afbeelding 1 (opgeslagen in data[]) een binaire boom maakt op basis van bovenstaande structuur en typedefinities. Gebruik onderstaand functie prototype.

Hoe dien je bovenstaande functie te gebruiken?

Knoop A heeft als kinderen B en F (zie afbeelding 1).

Knoop A krijgt index = 0. De kinderen van A zijn dan te vinden in data[1] (knoop B) en data[2] (knoop F). Knoop B krijgt dus index = 1 in data[] en knoop F krijgt index = 2 in data[].

Algemeen opgeschreven:

De kinderen van knoop data[i] zijn te vinden in data[2*i+1] en data[2*i+2].

Met dit gegeven kun je data[] vullen met de knopen A, B, C, .., en H.

2.2 Maak een testprogramma met recursieve functie traverseTree(). Deze functie dient de boom te doorlopen op de ‘depth first’ wijze, d.w.z. eerst afdalen naar de bladeren (C,E,…) alvorens data op te halen van hoger gelegen takken. De gewenste volgorde dient te zijn: **CEDBGHFA. Laat d.m.v. printf’s zien dat bovenstaande functionaliteit correct werkt.

Bijlagen

1. Bijlage Bit-manipulatie: bresenham.h, bresenham.c (aanwerk), main.c

2. Bijlage Een binaire boom: binaireboom.h, binaireboom.c (aanwerk), main.c

Bijlage 1: Bit-manipulatie

bresenham.h

//

// bresenham.h

// PracticumBresenham

//

// Created by Jan on 8/9/17.

// Copyright © 2017 Jan. All rights reserved.

//

#ifndef bresenham_h

#define bresenham_h

#include

int bm[32]; // global bitmap

void p();

void hl(int x1, int x2, int y);

void vl(int y1, int y2, int x);

void bh(int x1, int y1, int x2, int y2);

void ci(int x0, int y0, int radius);

#endif /* bresenham_h */

bresenham.c (aanwerk)

//

// bresenham.c

// PracticumBresenham

//

// Created by Jan on 8/9/17.

// Copyright © 2017 Jan. All rights reserved.

//

#include "bresenham.h"

#include

#include

void p(){

}

void plt(int x, int y) {

}

void hl(int x1, int x2, int y) {

}

void vl(int y1, int y2, int x){

}

void bh(int x1, int y1, int x2, int y2){

}

void ci(int x0, int y0, int radius){

 …

}

main.c

//

// main.c

// PracticumBresenham

//

// Created by Jan Jacobs on 8/9/2017.

// Copyright © 2017 Jan. All rights reserved.

//

//

#include

#include "bresenham.h"

int main(int argc, const char * argv[]) {

// 1)

    p(); // print before

// 2) plt() // plot function

// 3)

    hl(1,5,2); // draw horizontal line

 p();

// for (int i = 0; i < 32; i++)printf("%d\n", bm[i]);

// 4)

 vl(2,4,7); // draw vertical line

    p(); // print after

// 5)

 bh(3, 3, 12, 8);

 p(); // print the result of Bresenham line

// 6)

 ci(15, 15, 15);

 ci(15,15, 7);

 p();

 return 0;

}

Bijlage 2: Een binaire boom

binaireboom.h

//

// Created by Ralf on 03/11/15.

// Copyright © 2015 Ralf. All rights reserved.

//

// Updated with traverseTree, by Jan 1/9/17

//

#include

#include "binaireboom.h"

int main(int argc, const char * argv[]) {

    BINBOOM boom = NULL;

    DATA data[10] = {'A', 'B', 'F', 'C', 'D', 'G', 'H', '*', '*', 'E'};

    // A (index = 0)

    // B (index = 1)

    // D (index = 4)

    // F (index = 2)

    boom = maak_boom(data);

 traverseTree(boom);

    return 0;

}

binaireboom.c (aanwerk)

//

// binaireboom.c

// PracticumBinaireBoom

//

// Created by Ralf on 03/11/15.

// Copyright © 2015 Ralf. All rights reserved.

//

#include "binaireboom.h"

#include

BINBOOM plaats_knoop(DATA data, BINBOOM links, BINBOOM rechts) {

    BINBOOM temp;

    temp = malloc(sizeof(KNOOP));

    if (NULL!= temp) {

        temp->d = data;

        temp->links = links;

        temp->rechts = rechts;

    }

 printf("created %c KNOOP on heap with left and right BINBOOMs\n", data);

    return temp;

}

BINBOOM maak_boom_recursief(DATA data[], int i, int grootte) {

    if (i>=grootte) {

        return NULL;

    }

    else {

    }

}

BINBOOM maak_boom(DATA data[]) {

    BINBOOM boom = maak_boom_recursief(data, 0, 10);

    return boom;

}

int traverseTree(BINBOOM tree){

 return 1;

}

main.c

//

// Created by Ralf on 03/11/15.

// Copyright © 2015 Ralf. All rights reserved.

//

// Updated with traverseTree, by Jan 1/9/17

//

#include

#include "binaireboom.h"

int main(int argc, const char * argv[]) {

    BINBOOM boom = NULL;

    DATA data[10] = {'A', 'B', 'F', 'C', 'D', 'G', 'H', '*', '*', 'E'};

    // A (index = 0)

    // B (index = 1)

    // D (index = 4)

    // F (index = 2)

    boom = maak_boom(data);

    traverseTree(boom);

    return 0;

}