Мозаика из правильных шестиугольников

@4ewka · Регистрация: 05.12.2014

Студворк — интернет-сервис помощи студентам

Выручайте, ребята. Срочно нужно создать программу для прорисовки мазайки из правильных шестиугольников закрашеных разным цветом. Размер шестиугольников задается 3 способами на выбор пользователя : с клавиатуры, из текстового файла, случайной генерацией. То есть все 3 варианта должны быть реализованы.

@SatanaXIII · 26.12.2014, 10:09

Что-то с геометрией какая-то хрень, но для сельской местности потянет:

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
void __fastcall TForm1::Button1Click(TObject *Sender)
{
const int r = 40,
          stepX = r*3,
          stepY = r*sqrt(3);
const double PI = 3.1415926535;
 
for( double y=0; (y-1)*stepY<Image1->Height; y+=0.5 )
  for( double temp, x=modf( y, &temp ); (x-1)*stepX<Image1->Width; x+=1 )
    {
    Image1->Canvas->Brush->Color = (TColor)RGB( rand()%250, rand()%5, rand()%250 );
    Image1->Canvas->MoveTo( cos(0)*r + stepX * x, sin(0)*r + stepY * y );
    for( double f=0.; f<=2.*PI; f+=PI/3. )
      Image1->Canvas->LineTo( cos(f)*r + stepX * x, sin(f)*r + stepY * y );
 
    double ReachBordX = x*stepX>Image1->Width  ? r/2. : 0,
           ReachBordY = y*stepY>Image1->Height ? r/2. : 0;
 
    Image1->Canvas->FloodFill( cos(0)*r + stepX * x - r - ReachBordX,
                               sin(0)*r + stepY * y - ReachBordY,
                               clWhite,
                               fsSurface );
    }
}

Сообщение от 4ewka

То есть все 3 варианта должны быть реализованы.

Дудки.

P.S. Странно что gunslinger проигнорировал тему. Он тоже вроде любит порисовать всякую хрень в свое удовольствие.

@4ewka · 29.12.2014, 09:47 **[ТС]**

Перевести код из Delphi 7 в Builder 6
Нет, не странно (:
Спасибо за помощь (:

@gunslinger · 29.12.2014, 15:49

Можно еще так:

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
void figure(TCanvas *canvas, TPoint center, UINT radius, TColor color)
{
  const num_of_points = 6;  // для шестиугольника (hexagon)
  TPoint points[num_of_points];
  Byte i;
  // начальный угол влияет на "положение" фигуры
  UINT angle = 30;  // 360/num_of_points/2;
  for (i = 0; i < num_of_points; i++)
  {
    points[i].x = center.x + cos(angle*M_PI/180) * radius;
    points[i].y = center.y + sin(angle*M_PI/180) * radius;
    angle += 60;  // 360/num_of_points;
  }
  canvas->Pen->Color = color;
  canvas->Brush->Color = color;
  canvas->Polygon(points, num_of_points-1);
}
//---------------------------------------------------------------------------
void __fastcall TForm1::Button1Click(TObject *Sender)
{
  const dim = 8;
  UINT border = 50, radius = 30;
  bool temp;
  TPoint center;
  TColor color;
  randomize();
  for (Byte i = 0; i < dim+2; i++)
    for (Byte j = 0; j < dim; j++)
    {
      temp = i%2 ? 1 : 0;
      center = TPoint(border+j*radius*2*cos(30*M_PI/180)+temp*radius*sin(60*M_PI/180), border+i*(radius*(2-sin(30*M_PI/180))));
      // цвет можно задать и через побитовое смещение <<, но это будет менее наглядно
      color = TColor(RGB(random(256), random(256), random(256)));
      figure(Canvas, center, radius, color);
    }
}

@gunslinger · 29.12.2014, 15:58

Упрощенная 31 строка:

C++
1
center = TPoint(border+radius*cos(30*M_PI/180)*(j*2+temp), border+radius*(2-sin(30*M_PI/180))*i);

@SatanaXIII · 29.12.2014, 17:12

Починил геометрию. Сделал мерцание. Очень красиво по моему.

Код

ClassHexagon.h

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
//---------------------------------------------------------------------------
 
#ifndef ClassHexagonH
#define ClassHexagonH
//---------------------------------------------------------------------------
#include <vcl>
#pragma hdrstop
//---------------------------------------------------------------------------
class Hexagon
{
public:
        Hexagon() : Color( clWhite ),
                    MaxR(250), MaxG(5), MaxB(250),
                    step(5)
          {
          DirectionR = RGBA.R >= MaxR? -1 : 1;
          DirectionG = RGBA.G >= MaxG? -1 : 1;
          DirectionB = RGBA.B >= MaxB? -1 : 1;
          };
 
        void twinkle()
          {
          if( RGBA.R + step>= MaxR || RGBA.R - step<= 0 )
            DirectionR *= -1;
          RGBA.R += DirectionR * step;
 
          if( RGBA.G + step>= MaxG || RGBA.G - step<= 0 )
            DirectionG *= -1;
          RGBA.G += DirectionG * step;
 
          if( RGBA.B + step>= MaxB || RGBA.B - step<= 0 )
            DirectionB *= -1;
          RGBA.B += DirectionB * step;
          };
 
 
 
        union
        {
        TColor Color;
        struct
          {
          unsigned char R;
          unsigned char G;
          unsigned char B;
          unsigned char A;
          } RGBA;
        };
        static TColor BorderColor;
        static int Radius;
 
        TPoint Angles[6];
 
        TPoint Index;
private:
        const int MaxR;
        const int MaxG;
        const int MaxB;
 
        int DirectionR;
        int DirectionG;
        int DirectionB;
 
        const int step;
};
//---------------------------------------------------------------------------
TColor Hexagon::BorderColor;
int Hexagon::Radius;
//---------------------------------------------------------------------------
#endif

Unit1.h

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
//---------------------------------------------------------------------------
 
#ifndef Unit1H
#define Unit1H
//---------------------------------------------------------------------------
#include <Classes.hpp>
#include <Controls.hpp>
#include <StdCtrls.hpp>
#include <Forms.hpp>
#include <ExtCtrls.hpp>
//---------------------------------------------------------------------------
#include <vector>
//---------------------------------------------------------------------------
#include "ClassHexagon.h"
//---------------------------------------------------------------------------
enum SeedMosaicMode_e { RandomHexagon, GroupHexagon };
 
class TForm1 : public TForm
{
__published:    // IDE-managed Components
        TImage *Image1;
        TBevel *Bevel1;
        TTimer *Timer1;
        void __fastcall Timer1Timer(TObject *Sender);
        void __fastcall PaintMosaic();
        void __fastcall SeedMosaic( SeedMosaicMode_e SeedMode );
        void __fastcall FormClose(TObject *Sender, TCloseAction &Action);
        void __fastcall FormResize(TObject *Sender);
private:    // User declarations
        int stepX,
            stepY;
        const double PI;
        std::vector<Hexagon> Hexagons;
 
        Graphics::TBitmap *bitmap;
public:     // User declarations
        __fastcall TForm1(TComponent* Owner);
};
//---------------------------------------------------------------------------
extern PACKAGE TForm1 *Form1;
//---------------------------------------------------------------------------
#endif

Unit1.cpp

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
//---------------------------------------------------------------------------
 
#include <vcl.h>
#include <math>
#include <stdlib>
#pragma hdrstop
 
#include "Unit1.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"
TForm1 *Form1;
//---------------------------------------------------------------------------
__fastcall TForm1::TForm1(TComponent* Owner)
        : TForm(Owner),
        PI( 3.1415926535 )
{
srand( time( NULL ) );
this->DoubleBuffered = true;
 
bitmap = new Graphics::TBitmap;
this->Resize();
 
SeedMosaic( RandomHexagon );
}
//---------------------------------------------------------------------------
void __fastcall TForm1::SeedMosaic( SeedMosaicMode_e SeedMode )
{
Hexagon CurrHexagon;
CurrHexagon.BorderColor = clBlack;
CurrHexagon.Radius = 10;
 
stepX = CurrHexagon.Radius * 3;
stepY = CurrHexagon.Radius * sqrt(3);
 
for( double y=0, indexX=0; (y-1)*stepY<Image1->Height; y+=0.5, indexX++ )
  for( double f, indexY=0, x=modf( y, &f ); (x-1)*stepX<Image1->Width; x+=1, indexY++ )
    {
    int count( 0 );
    for( f=-PI; f<PI; f+=PI/3., ++count ) // По часовой стрелке, начиная с девяти часов
      {
      CurrHexagon.Angles[count].x = cos(f)*CurrHexagon.Radius + stepX * x;
      CurrHexagon.Angles[count].y = sin(f)*CurrHexagon.Radius + stepY * y;
      }
    CurrHexagon.Color = (TColor)RGB( rand()%250, rand()%5, rand()%250 );
 
    if( SeedMode == GroupHexagon )
      {
      CurrHexagon.Index.x = indexX;
      CurrHexagon.Index.y = indexX + indexY;
      }
 
    this->Hexagons.push_back( CurrHexagon );
    } // end for
 
if( SeedMode == GroupHexagon )
  {
  for( std::vector<Hexagon>::iterator CurrHexagon = Hexagons.begin();
     CurrHexagon != Hexagons.end();
     ++CurrHexagon )
    {
    CurrHexagon->Color = clWhite;
    }
 
  // Лениво доделывать
  }
}
//---------------------------------------------------------------------------
void __fastcall TForm1::Timer1Timer(TObject *Sender)
{
PaintMosaic();
}
//---------------------------------------------------------------------------
void __fastcall TForm1::PaintMosaic()
{
for( std::vector<Hexagon>::iterator CurrHexagon = Hexagons.begin();
     CurrHexagon != Hexagons.end();
     ++CurrHexagon )
    {
    bitmap->Canvas->MoveTo( CurrHexagon->Angles[5].x, CurrHexagon->Angles[5].y );
    for( int i=0; i<6; ++i )
        bitmap->Canvas->LineTo( CurrHexagon->Angles[i].x, CurrHexagon->Angles[i].y );
 
    const int PenWith = bitmap->Canvas->Pen->Width + 1;
    double ReachBordX = CurrHexagon->Angles[4].x < bitmap->Width  ?       // Много магических углов
                        CurrHexagon->Angles[4].x - PenWith : CurrHexagon->Angles[1].x + PenWith,
           ReachBordY = CurrHexagon->Angles[4].y < bitmap->Height ?
                        CurrHexagon->Angles[4].y - PenWith : CurrHexagon->Angles[1].y + PenWith;
 
 
    CurrHexagon->twinkle();
 
    bitmap->Canvas->Brush->Color = CurrHexagon->Color;
    bitmap->Canvas->FloodFill( ReachBordX,
                               ReachBordY,
                               CurrHexagon->BorderColor,
                               fsBorder );
    }
 
Image1->Canvas->Draw( 0, 0, bitmap );
}
//---------------------------------------------------------------------------
 
void __fastcall TForm1::FormResize(TObject *Sender)
{
bitmap->Width = Image1->Width;
bitmap->Height = Image1->Height;
}
//---------------------------------------------------------------------------
 
void __fastcall TForm1::FormClose(TObject *Sender, TCloseAction &Action)
{
delete bitmap;
//Hexagons.clear();
}
//---------------------------------------------------------------------------

Надо сделать еще плавный переход цвета на соседние ячейки, а не рандомный и будет вообще крутяк. Мож потом как-нибудь доделаю эту хрень.

@4ewka · 30.12.2014, 01:39 **[ТС]**

Господа, может кто объяснить что вообще такое unit.h и unit.cpp? Я как бы до этого момента даже не задумывался, а сейчас увидел в коде юнит.цпп и понял, что мне ещё учиться учиться

Новые блоги и статьи Все статьи Все блоги /
SDL3 для Web (WebAssembly): Реализация движения на Box2D v3 - трение и коллизии с повёрнутыми стенами 8Observer8 20.02.2026 Содержание блога Box2D позволяет легко создать главного героя, который не проходит сквозь стены и перемещается с заданным трением о препятствия, которые можно располагать под углом, как верхнее. . .	Конвертировать закладки radiotray-ng в m3u-плейлист damix 19.02.2026 Это можно сделать скриптом для PowerShell. Использование . \СonvertRadiotrayToM3U. ps1 <path_to_bookmarks. json> Рядом с файлом bookmarks. json появится файл bookmarks. m3u с результатом. # Check if. . .	Семь CDC на одном интерфейсе: 5 U[S]ARTов, 1 CAN и 1 SSI Eddy_Em 18.02.2026 Постепенно допиливаю свою "многоинтерфейсную плату". Выглядит вот так: https:/ / www. cyberforum. ru/ blog_attachment. php?attachmentid=11617&stc=1&d=1771445347 Основана на STM32F303RBT6. На борту пять. . .	Камера Toupcam IUA500KMA Eddy_Em 12.02.2026 Т. к. у всяких "хикроботов" слишком уж мелкий пиксель, для подсмотра в ESPriF они вообще плохо годятся: уже 14 величину можно рассмотреть еле-еле лишь на экспозициях под 3 секунды (а то и больше),. . .
И ясному Солнцу zbw 12.02.2026 И ясному Солнцу, и светлой Луне. В мире покоя нет и люди не могут жить в тишине. А жить им немного лет.	«Знание-Сила» zbw 12.02.2026 «Знание-Сила» «Время-Деньги» «Деньги -Пуля»	SDL3 для Web (WebAssembly): Подключение Box2D v3, физика и отрисовка коллайдеров 8Observer8 12.02.2026 Содержание блога Box2D - это библиотека для 2D физики для анимаций и игр. С её помощью можно определять были ли коллизии между конкретными объектами и вызывать обработчики событий столкновения. . . .	SDL3 для Web (WebAssembly): Загрузка PNG с прозрачным фоном с помощью SDL_LoadPNG (без SDL3_image) 8Observer8 11.02.2026 Содержание блога Библиотека SDL3 содержит встроенные инструменты для базовой работы с изображениями - без использования библиотеки SDL3_image. Пошагово создадим проект для загрузки изображения. . .

@4ewka 20 / 13 / 9 Регистрация: 05.12.2014 Сообщений: 124

	Мозаика из правильных шестиугольников 23.12.2014, 22:03. Показов 2781. Ответов 6 Метки нет (Все метки) Выручайте, ребята. Срочно нужно создать программу для прорисовки мазайки из правильных шестиугольников закрашеных разным цветом. Размер шестиугольников задается 3 способами на выбор пользователя : с клавиатуры, из текстового файла, случайной генерацией. То есть все 3 варианта должны быть реализованы. 0

@4ewka 20 / 13 / 9 Регистрация: 05.12.2014 Сообщений: 124
	29.12.2014, 09:47 [ТС]
	Перевести код из Delphi 7 в Builder 6 Нет, не странно (: Спасибо за помощь (: 0

@4ewka 20 / 13 / 9 Регистрация: 05.12.2014 Сообщений: 124
	30.12.2014, 01:39 [ТС]
	Господа, может кто объяснить что вообще такое unit.h и unit.cpp? Я как бы до этого момента даже не задумывался, а сейчас увидел в коде юнит.цпп и понял, что мне ещё учиться учиться 0