NoPaste

zeichen2zufall

von heinz
Beschreibung:
zeichen2zufall
Snippet erstellt:
07.01.2019 18:36:31
Snippet wird automatisch gelöscht:
Niemals

Dein Code:
  1. /*
  2.         Zeichen einer Datei durch Zufallszahlen ersetzen.
  3.  
  4.         Dieses Programm ersetzt alle gefundenen "Marker-Zeichen" durch eine Zufalls-Zahl.
  5.         Gedacht war dieses Programm, um in POV-/ASCII-Dateien zufallswerte einzusetzen.
  6.  
  7.  
  8.         Man kann bis zu 3 Zeichen gleichzeitig ersetzen.
  9.  
  10.         Die Marker (-m/-n/-o) duerfen dabei nur aus einem Zeichen bestehen.
  11.         Achten Sie darauf, dass die Marker in der Quelldatei nur an den Stellen vorkommen,
  12.         die auch ersetzt werden sollen.
  13.  
  14.  
  15.         Die Bereiche werden mit 1 oder 2 Werten angegeben (-1/-3/-5 und -2/-4/-6)
  16.         Sie koennen fuer fuer jeden Bereich auch einen Teiler (-t/-u/-v) angeben,
  17.         um Kommazahlen zu erzeugen.
  18.         Die Bedeutung der Werte ist:
  19.                 rand()% ( wert1 + wert2 ) / teiler1
  20.         z.B.
  21.                 z2z -1 1000 -2 -500
  22.                 erzeugt Zufallszahlen im Bereich von -500 bis 499.
  23.                 z2z -1 1000 -2 -500 -t 10
  24.                 erzeugt Zufallszahlen im Bereich von -50.0 bis 49.9.
  25.         Der zweite Wert (-2/-4/-6) kann weggelassen werden.
  26.         z.B.
  27.                 z2z -1 1000
  28.                 erzeugt Zufallszahlen im Bereich von 0 bis 999.
  29.                 z2z -1 1000 -t 10
  30.                 erzeugt Zufallszahlen im Bereich von 0 bis 99.9.
  31. */
  32.  
  33.  
  34.  
  35. #define DEBUG true
  36.  
  37.  
  38. char VERSION[10]={"0.20"};
  39.  
  40.  
  41.  
  42. #include <stdlib.h>
  43. #include <getopt.h>
  44. #include <fstream>
  45. #include <string.h>
  46. #include <math.h>
  47.  
  48. #include <fcntl.h>
  49. #include <unistd.h>
  50.  
  51. int urandom_fd = -2;
  52.  
  53.  
  54. // Typen -------------------------------------------------------------------------------------------
  55. struct option opts[]={
  56.       {"quelldatei",      required_argument,0,  'q'},
  57.       {"zieldatei",       required_argument,0,  'z'},
  58.  
  59.       {"marker1",         required_argument,0,  'm'},
  60.       {"bereich1",        required_argument,0,  '1'},
  61.       {"bereich2",        required_argument,0,  '2'},
  62.       {"teiler1",         required_argument,0,  't'},
  63.       {"marker2",         required_argument,0,  'n'},
  64.       {"bereich3",        required_argument,0,  '3'},
  65.       {"bereich4",        required_argument,0,  '4'},
  66.       {"teiler2",         required_argument,0,  'u'},
  67.       {"marker3",         required_argument,0,  'o'},
  68.       {"bereich5",        required_argument,0,  '5'},
  69.       {"bereich6",        required_argument,0,  '6'},
  70.       {"teiler3",         required_argument,0,  'v'},
  71.  
  72.       {"markerR",         required_argument,0,  'M'},
  73.       {"radiusX",         required_argument,0,  'X'},
  74.       {"radius_minX",     required_argument,0,  'A'},
  75.       {"teilerX",         required_argument,0,  'T'},
  76.       {"radiusY",         required_argument,0,  'Y'},
  77.       {"radius_minY",     required_argument,0,  'B'},
  78.       {"teilerY",         required_argument,0,  'U'},
  79.       {"radiusZ",         required_argument,0,  'Z'},
  80.       {"radius_minZ",     required_argument,0,  'C'},
  81.       {"teilerZ",         required_argument,0,  'V'},
  82.       {"help",            no_argument,      0,  'h'},
  83.       {0,                 0,                0,    0}
  84. };
  85.  
  86.  
  87.  
  88.  
  89.  
  90. // Globales ----------------------------------------------------------------------------------------
  91. const int max_zeilenlaenge=1024;
  92. char quellname[max_zeilenlaenge]={""};
  93. char zielname[max_zeilenlaenge]={""};
  94.  
  95. char marker1[max_zeilenlaenge]={""};
  96. char bereich1[max_zeilenlaenge]={""};
  97. char bereich2[max_zeilenlaenge]={""};
  98. char teiler1[max_zeilenlaenge]={""};
  99.  
  100. char marker2[max_zeilenlaenge]={""};
  101. char bereich3[max_zeilenlaenge]={""};
  102. char bereich4[max_zeilenlaenge]={""};
  103. char teiler2[max_zeilenlaenge]={""};
  104.  
  105. char marker3[max_zeilenlaenge]={""};
  106. char bereich5[max_zeilenlaenge]={""};
  107. char bereich6[max_zeilenlaenge]={""};
  108. char teiler3[max_zeilenlaenge]={""};
  109.  
  110. char markerR[max_zeilenlaenge]={""};
  111. char radiusX[max_zeilenlaenge]={""};
  112. char radius_minX[max_zeilenlaenge]={""};
  113. char teilerX[max_zeilenlaenge]={""};
  114.  
  115. char radiusY[max_zeilenlaenge]={""};
  116. char radius_minY[max_zeilenlaenge]={""};
  117. char teilerY[max_zeilenlaenge]={""};
  118.  
  119. char radiusZ[max_zeilenlaenge]={""};
  120. char radius_minZ[max_zeilenlaenge]={""};
  121. char teilerZ[max_zeilenlaenge]={""};
  122.  
  123.  
  124. const double Pi=3.14159265358979323846264338327950288419716939937510582097494459230781640628620899;
  125.  
  126.  
  127.  
  128.  
  129. // Funktionen --------------------------------------------------------------------------------------
  130. void Bedienung();
  131. /*
  132. void urandom_init()
  133. unsigned long urandom();
  134. */
  135. void test();
  136.  
  137. float MyRandom( float Bereich );
  138.  
  139.  
  140.  
  141.  
  142.  
  143. // Hauptprogramm ###################################################################################
  144. int main(int argc, char *argv[])
  145. {
  146. //test();
  147.         bool stdout=true;
  148.  
  149.         if(argc==1){Bedienung();}
  150.  
  151.         int optc=0;
  152.         while((optc=getopt_long(argc,argv,"q:z:m:1:2:t:n:3:4:u:o:5:6:v:M:X:A:T:N:Y:B:U:O:Z:C:V:h",opts,NULL))!=EOF)
  153.         {
  154.                 switch(optc)
  155.                 {
  156. // Quelldatei
  157.                         case'q':
  158.                                 strncat(quellname,optarg,max_zeilenlaenge-1);
  159.                         break;
  160. // Zieldatei
  161.                         case'z':
  162.                                 strncat(zielname,optarg,max_zeilenlaenge-1);
  163.                                 stdout=false;
  164.                         break;
  165.  
  166.  
  167. // Marker1
  168.                         case'm':
  169.                                 strncat(marker1,optarg,max_zeilenlaenge-1);
  170.                                 if(strlen(marker1)!=1)
  171.                                 {
  172.                                         printf("\aDer Marker 1 muss aus EINEM Zeichen Bestehen! >%s<\n",marker1);
  173.                                         exit(1);
  174.                                 }
  175.                         break;
  176. // Bereich 1
  177.                         case'1':
  178.                                 strncat(bereich1,optarg,max_zeilenlaenge-1);
  179.                                 if(atoi(bereich1)==0)
  180.                                 {
  181.                                         printf("\aDer Bereich 1 ist fehlerhaft! >%s<\n",bereich1);
  182.                                         exit(1);
  183.                                 }
  184.                         break;
  185. // Bereich 2
  186.                         case'2':
  187.                                 strncat(bereich2,optarg,max_zeilenlaenge-1);
  188.                                 if(atoi(bereich2)==0)
  189.                                 {
  190.                                         printf("\aDer Bereich 2 ist fehlerhaft! >%s<\n",bereich2);
  191.                                         exit(1);
  192.                                 }
  193.                         break;
  194. // Teiler 1
  195.                         case't':
  196.                                 strncat(teiler1,optarg,max_zeilenlaenge-1);
  197.                                 if(atoi(teiler1)==0)
  198.                                 {
  199.                                         printf("\aDer Teiler 1 ist fehlerhaft! >%s<\n",teiler1);
  200.                                         exit(1);
  201.                                 }
  202.                         break;
  203.  
  204.  
  205. // Marker2
  206.                         case'n':
  207.                                 strncat(marker2,optarg,max_zeilenlaenge-1);
  208.                                 if(strlen(marker2)!=1)
  209.                                 {
  210.                                         printf("\aDer Marker 2 muss aus EINEM Zeichen Bestehen! >%s<\n",marker2);
  211.                                         exit(1);
  212.                                 }
  213.                         break;
  214. // Bereich 3
  215.                         case'3':
  216.                                 strncat(bereich3,optarg,max_zeilenlaenge-1);
  217.                                 if(atoi(bereich3)==0)
  218.                                 {
  219.                                         printf("\aDer Bereich 3 ist fehlerhaft! >%s<\n",bereich3);
  220.                                         exit(1);
  221.                                 }
  222.                         break;
  223. // Bereich 4
  224.                         case'4':
  225.                                 strncat(bereich4,optarg,max_zeilenlaenge-1);
  226.                                 if(atoi(bereich4)==0)
  227.                                 {
  228.                                         printf("\aDer Bereich 4 ist fehlerhaft! >%s<\n",bereich4);
  229.                                         exit(1);
  230.                                 }
  231.                         break;
  232. // Teiler 2
  233.                         case'u':
  234.                                 strncat(teiler2,optarg,max_zeilenlaenge-1);
  235.                                 if(atoi(teiler2)==0)
  236.                                 {
  237.                                         printf("\aDer Teiler 2 ist fehlerhaft! >%s<\n",teiler2);
  238.                                         exit(1);
  239.                                 }
  240.                         break;
  241.  
  242.  
  243. // Marker3
  244.                         case'o':
  245.                                 strncat(marker3,optarg,max_zeilenlaenge-1);
  246.                                 if(strlen(marker3)!=1)
  247.                                 {
  248.                                         printf("\aDer Marker 3 muss aus EINEM Zeichen Bestehen! >%s<\n",marker3);
  249.                                         exit(1);
  250.                                 }
  251.                         break;
  252. // Bereich 5
  253.                         case'5':
  254.                                 strncat(bereich5,optarg,max_zeilenlaenge-1);
  255.                                 if(atoi(bereich5)==0)
  256.                                 {
  257.                                         printf("\aDer Bereich 5 ist fehlerhaft! >%s<\n",bereich5);
  258.                                         exit(1);
  259.                                 }
  260.                         break;
  261. // Bereich 6
  262.                         case'6':
  263.                                 strncat(bereich6,optarg,max_zeilenlaenge-1);
  264.                                 if(atoi(bereich6)==0)
  265.                                 {
  266.                                         printf("\aDer Bereich 6 ist fehlerhaft! >%s<\n",bereich6);
  267.                                         exit(1);
  268.                                 }
  269.                         break;
  270. // Teiler 3
  271.                         case'v':
  272.                                 strncat(teiler3,optarg,max_zeilenlaenge-1);
  273.                                 if(atoi(teiler3)==0)
  274.                                 {
  275.                                         printf("\aDer Teiler 3 ist fehlerhaft! >%s<\n",teiler3);
  276.                                         exit(1);
  277.                                 }
  278.                         break;
  279.  
  280.  
  281. // Marker R
  282.                         case'M':
  283.                                 strncat(markerR,optarg,max_zeilenlaenge-1);
  284.                                 if(strlen(markerR)!=1)
  285.                                 {
  286.                                         printf("\aDer Marker R muss aus EINEM Zeichen Bestehen! >%s<\n",markerR);
  287.                                         exit(1);
  288.                                 }
  289.                         break;
  290. // Radius X
  291.                         case'X':
  292.                                 strncat(radiusX,optarg,max_zeilenlaenge-1);
  293.                                 if(atoi(radiusX)==0)
  294.                                 {
  295.                                         printf("\aDer Radius X ist fehlerhaft! >%s<\n",radiusX);
  296.                                         exit(1);
  297.                                 }
  298.                         break;
  299. // Radius X min
  300.                         case'A':
  301.                                 strncat(radius_minX,optarg,max_zeilenlaenge-1);
  302.                                 if(atoi(radius_minX)==0||atoi(radius_minX)>=atoi(radiusX))
  303.                                 {
  304.                                         printf("\aDer Min.Radius X ist fehlerhaft! >%s<\n",radius_minX);
  305.                                         exit(1);
  306.                                 }
  307.                         break;
  308. // Teiler X
  309.                         case'T':
  310.                                 strncat(teilerX,optarg,max_zeilenlaenge-1);
  311.                                 if(atoi(teilerX)==0)
  312.                                 {
  313.                                         printf("\aDer Teiler X ist fehlerhaft! >%s<\n",teilerX);
  314.                                         exit(1);
  315.                                 }
  316.                         break;
  317.  
  318.  
  319. // Radius Y
  320.                         case'Y':
  321.                                 strncat(radiusY,optarg,max_zeilenlaenge-1);
  322.                                 if(atoi(radiusY)==0)
  323.                                 {
  324.                                         printf("\aDer Radius Y ist fehlerhaft! >%s<\n",radiusY);
  325.                                         exit(1);
  326.                                 }
  327.                         break;
  328. // Radius Y min
  329.                         case'B':
  330.                                 strncat(radius_minY,optarg,max_zeilenlaenge-1);
  331.                                 if(atoi(radius_minY)==0||atoi(radius_minY)>=atoi(radiusY))
  332.                                 {
  333.                                         printf("\aDer Min.Radius Y ist fehlerhaft! >%s<\n",radius_minY);
  334.                                         exit(1);
  335.                                 }
  336.                         break;
  337. // Teiler Y
  338.                         case'U':
  339.                                 strncat(teilerY,optarg,max_zeilenlaenge-1);
  340.                                 if(atoi(teilerY)==0)
  341.                                 {
  342.                                         printf("\aDer Teiler Y ist fehlerhaft! >%s<\n",teilerY);
  343.                                         exit(1);
  344.                                 }
  345.                         break;
  346.  
  347.  
  348. // Radius Z
  349.                         case'Z':
  350.                                 strncat(radiusZ,optarg,max_zeilenlaenge-1);
  351.                                 if(atoi(radiusZ)==0)
  352.                                 {
  353.                                         printf("\aDer Radius Z ist fehlerhaft! >%s<\n",radiusZ);
  354.                                         exit(1);
  355.                                 }
  356.                         break;
  357. // Radius Z min
  358.                         case'C':
  359.                                 strncat(radius_minZ,optarg,max_zeilenlaenge-1);
  360.                                 if(atoi(radius_minZ)==0||atoi(radius_minZ)>=atoi(radiusZ))
  361.                                 {
  362.                                         printf("\aDer Min.Radius Z ist fehlerhaft! >%s<\n",radius_minZ);
  363.                                         exit(1);
  364.                                 }
  365.                         break;
  366. // Teiler Z
  367.                         case'V':
  368.                                 strncat(teilerZ,optarg,max_zeilenlaenge-1);
  369.                                 if(atoi(teilerZ)==0)
  370.                                 {
  371.                                         printf("\aDer Teiler Z ist fehlerhaft! >%s<\n",teilerZ);
  372.                                         exit(1);
  373.                                 }
  374.                         break;
  375.  
  376.  
  377. // Fehlermeldung
  378.                         default:
  379.                                 printf("\a\nVerwenden Sie z2z --help fuer Hilfe!\n\n");
  380.                                 exit(1);
  381.                         break;
  382. // Hilfe
  383.                         case'h':
  384.                                 Bedienung();
  385.                         break;
  386.                 }
  387.         }
  388.  
  389.  
  390.  
  391.  
  392.  
  393. //printf("---------------->%s%s< >%i + %i<\n",bereich1,bereich2,atoi(bereich1),atoi(bereich2));
  394.  
  395. #if DEBUG
  396.         fprintf(stderr,"Quelldatei >%s<\nZieldatei >%s<\n",quellname,(strlen(zielname)>0)?zielname:"stdout");
  397.         if(strlen(marker1)>0)
  398.         {
  399.                 fprintf(stderr,"Marker 1 >%s<\nBereich >%s %s%s%s<\n",marker1,bereich1,bereich2,(strlen(teiler1)>0)?" / ":"",(strlen(teiler1)>0)?teiler1:"");
  400.         }
  401.         if(strlen(marker2)>0)
  402.         {
  403.                 fprintf(stderr,"Marker 2 >%s<\nBereich >%s %s%s%s<\n",marker2,bereich3,bereich4,(strlen(teiler2)>0)?" / ":"",(strlen(teiler2)>0)?teiler2:"");
  404.         }
  405.         if(strlen(marker3)>0)
  406.         {
  407.                 fprintf(stderr,"Marker 3 >%s<\nBereich >%s %s%s%s<\n",marker3,bereich5,bereich6,(strlen(teiler3)>0)?" / ":"",(strlen(teiler3)>0)?teiler3:"");
  408.         }
  409.  
  410.         if(strlen(markerR)>0)
  411.         {
  412.                 fprintf(stderr,"Marker R >%s<\nRadius X >%s %s%s%s<\n",markerR,radiusX,radius_minX,(strlen(teilerX)>0)?" / ":"",(strlen(teilerX)>0)?teilerX:"");
  413.                 if(strlen(radiusY)>0)
  414.                 {
  415.                         fprintf(stderr,"Marker R >%s<\nRadius Y >%s %s%s%s<\n",markerR,radiusY,radius_minY,(strlen(teilerY)>0)?" / ":"",(strlen(teilerY)>0)?teilerY:"");
  416.                 }
  417.                 if(strlen(radiusZ)>0)
  418.                 {
  419.                         fprintf(stderr,"Marker R >%s<\nRadius Z >%s %s%s%s<\n",markerR,radiusZ,radius_minZ,(strlen(teilerZ)>0)?" / ":"",(strlen(teilerZ)>0)?teilerZ:"");
  420.                 }
  421.         }
  422. #endif
  423.  
  424.  
  425.  
  426. // Zufalls-Seed start
  427.         srandom(time(0));
  428.  
  429.  
  430.  
  431.  
  432. // Datei bearbeiten.
  433. #if DEBUG
  434.         fprintf(stderr,"Textdatei \"%s\" einlesen...\n",quellname);
  435. #endif
  436.  
  437.  
  438. // File-Handler erzeugen
  439. // Quelldatei
  440.         std::ifstream load(quellname,std::ios::in);
  441.         if(load==NULL)
  442.   {
  443.         fprintf(stderr,"\a>%s< konnte nicht geoeffnet werden!\n",quellname);
  444.                 exit(1);
  445.   }
  446.  
  447. // Zieldatei
  448.         std::fstream save;
  449.         if(!stdout)
  450.         {
  451.                 save.open(zielname,std::ios::out);
  452.                 if(save==NULL)
  453.                 {
  454.                 fprintf(stderr,"\akonnte >%s< nicht anlegen!\n",zielname);
  455.                         exit(1);
  456.                 }
  457.         }
  458.  
  459.  
  460.  
  461.  
  462. // Datei nach >Marker< durchsuchen und >Marker< ersetzen.
  463. #if DEBUG
  464.         fprintf(stderr,"Lese >%s<\nSchreibe >%s<\n",quellname,stdout?"stdout":zielname);
  465. #endif
  466.  
  467.  
  468.         char Z;
  469.         while(!load.eof())
  470.         {
  471. // Laden
  472.                 load.get(Z);
  473.  
  474.  
  475. // Speichern
  476.                 if(!stdout)
  477.                 {
  478. // in Datei
  479.                         if(Z==marker1[0])
  480.                         {
  481.                                 if(atoi(teiler1)>1)
  482.                                 {
  483.                                         save<<(float)(rand()%atoi(bereich1) + atoi(bereich2)) / atoi(teiler1);
  484.                                 }
  485.                                 else
  486.                                 {
  487.                                         save<<rand()%atoi(bereich1) + atoi(bereich2);
  488.                                 }
  489.                         }
  490.                         else if(Z==marker2[0])
  491.                         {
  492.                                 if(atoi(teiler2)>1)
  493.                                 {
  494.                                         save<<(float)(rand()%atoi(bereich3) + atoi(bereich4)) / atoi(teiler2);
  495.                                 }
  496.                                 else
  497.                                 {
  498.                                         save<<rand()%atoi(bereich3) + atoi(bereich4);
  499.                                 }
  500.                         }
  501.                         else if(Z==marker3[0])
  502.                         {
  503.                                 if(atoi(teiler3)>1)
  504.                                 {
  505.                                         save<<(float)(rand()%atoi(bereich5) + atoi(bereich6)) / atoi(teiler3);
  506.                                 }
  507.                                 else
  508.                                 {
  509.                                         save<<rand()%atoi(bereich5) + atoi(bereich6);
  510.                                 }
  511.                         }
  512.  
  513. /*                      else if(Z==markerR[0])
  514.                         {
  515.                                 float winkel=MyRandom(360.0);
  516.                                 float winkelZ=MyRandom(360.0);
  517.  
  518.                                 int radX=atoi(radiusX)-atoi(radius_minX);
  519.                                 if(radX<1){radX=1;}
  520.                                 int radY;
  521.                                 if(atoi(radiusY)>0)
  522.                                 {
  523.                                         radY=atoi(radiusY)-atoi(radius_minY);
  524.                                 }
  525.                                 else
  526.                                 {
  527.                                         radY=radX;
  528.                                 }
  529.                                 int radZ;
  530.                                 if(atoi(radiusZ)>0)
  531.                                 {
  532.                                         radZ=atoi(radiusZ)-atoi(radius_minZ);
  533.                                 }
  534.                                 else
  535.                                 {
  536.                                         radZ=0;
  537.                                 }
  538.  
  539.                                 int tX=atoi(teilerX);
  540.                                 if(tX<1){tX=1;}
  541.                                 int tY;
  542.                                 if(atoi(teilerY)>1)
  543.                                 {
  544.                                         tY=atoi(teilerY);
  545.                                 }
  546.                                 else
  547.                                 {
  548.                                         tY=tX;
  549.                                 }
  550.                                 int tZ;
  551.                                 if(atoi(teilerZ)>1)
  552.                                 {
  553.                                         tZ=atoi(teilerZ);
  554.                                 }
  555.                                 else
  556.                                 {
  557.                                         tZ=tX;
  558.                                 }
  559.  
  560.                                 if(tX>1||tY>1||tZ>1)
  561.                                 {
  562.                                         save<<sin(winkel*(Pi/180.0))*MyRandom(radX) / (float)tX;
  563.                                         save<<" , "<<cos(winkel*(Pi/180.0))*MyRandom(radY) / (float)tY;
  564.                                         if(radZ>0)
  565.                                         {
  566.                                                 save<<" , "<<(cos(winkelZ*(Pi/180.0))*sin(winkel*(Pi/180.0))*cos(winkel*(Pi/180.0)))*MyRandom(radZ) / (float)tZ;
  567.                                         }
  568.                                 }
  569.                                 else
  570.                                 {
  571.                                         save<<round(sin(winkel*(Pi/180.0))*MyRandom(radX));
  572.                                         save<<" , "<<round(cos(winkel*(Pi/180.0))*MyRandom(radY));
  573.                                         if(radZ>0)
  574.                                         {
  575.                                                 save<<" , "<<round((cos(winkelZ*(Pi/180.0))*sin(winkel*(Pi/180.0))*cos(winkel*(Pi/180.0)))*MyRandom(radZ));
  576.                                         }
  577.                                 }
  578.                         }
  579. */
  580. /*
  581.                         else if(Z==markerR[0])
  582.                         {
  583.                                 double winkel=(double)(urandom()%36000000)/100000.0;
  584.                                 double winkelZ=(double)(urandom()%36000000)/100000.0;
  585.  
  586.                                 int radX=atoi(radiusX)-atoi(radius_minX);
  587.                                 if(radX<1){radX=1;}
  588.                                 int radY;
  589.                                 if(atoi(radiusY)>0)
  590.                                 {
  591.                                         radY=atoi(radiusY)-atoi(radius_minY);
  592.                                 }
  593.                                 else
  594.                                 {
  595.                                         radY=radX;
  596.                                 }
  597.                                 int radZ;
  598.                                 if(atoi(radiusZ)>0)
  599.                                 {
  600.                                         radZ=atoi(radiusZ)-atoi(radius_minZ);
  601.                                 }
  602.                                 else
  603.                                 {
  604.                                         radZ=0;
  605.                                 }
  606.  
  607.                                 int tX=atoi(teilerX);
  608.                                 if(tX<1){tX=1;}
  609.                                 int tY;
  610.                                 if(atoi(teilerY)>1)
  611.                                 {
  612.                                         tY=atoi(teilerY);
  613.                                 }
  614.                                 else
  615.                                 {
  616.                                         tY=tX;
  617.                                 }
  618.                                 int tZ;
  619.                                 if(atoi(teilerZ)>1)
  620.                                 {
  621.                                         tZ=atoi(teilerZ);
  622.                                 }
  623.                                 else
  624.                                 {
  625.                                         tZ=tX;
  626.                                 }
  627.  
  628.                                 if(tX>1||tY>1||tZ>1)
  629.                                 {
  630.                                         save<<sin(winkel*(Pi/180.0))*(urandom()%radX + atoi(radius_minX)) / (double)tX;
  631.                                         save<<" , "<<cos(winkel*(Pi/180.0))*(urandom()%radY + atoi(radius_minY)) / (double)tY;
  632.                                         if(radZ>0)
  633.                                         {
  634.                                                 save<<" , "<<(cos(winkelZ*(Pi/180.0))*sin(winkel*(Pi/180.0))*cos(winkel*(Pi/180.0)))*(urandom()%radZ + atoi(radius_minZ)) / (double)tZ;
  635.                                         }
  636.                                 }
  637.                                 else
  638.                                 {
  639.                                         save<<round(sin(winkel*(Pi/180.0))*(urandom()%radX + atoi(radius_minX)));
  640.                                         save<<" , "<<round(cos(winkel*(Pi/180.0))*(urandom()%radY + atoi(radius_minY)));
  641.                                         if(radZ>0)
  642.                                         {
  643.                                                 save<<" , "<<round((cos(winkelZ*(Pi/180.0))*sin(winkel*(Pi/180.0))*cos(winkel*(Pi/180.0)))*(urandom()%radZ + atoi(radius_minZ)));
  644.                                         }
  645.                                 }
  646.                         }
  647.  
  648. */
  649. /*                      else if(Z==markerR[0])
  650.                         {
  651.                                 float winkel=(float)(urandom()%36000000)/100000.0;
  652.                                 float winkelZ=(float)(urandom()%36000000)/100000.0;
  653.  
  654.                                 int radX=atoi(radiusX)-atoi(radius_minX);
  655.                                 if(radX<1){radX=1;}
  656.                                 int radY;
  657.                                 if(atoi(radiusY)>0)
  658.                                 {
  659.                                         radY=atoi(radiusY)-atoi(radius_minY);
  660.                                 }
  661.                                 else
  662.                                 {
  663.                                         radY=radX;
  664.                                 }
  665.                                 int radZ;
  666.                                 if(atoi(radiusZ)>0)
  667.                                 {
  668.                                         radZ=atoi(radiusZ)-atoi(radius_minZ);
  669.                                 }
  670.                                 else
  671.                                 {
  672.                                         radZ=0;
  673.                                 }
  674.  
  675.                                 int tX=atoi(teilerX);
  676.                                 if(tX<1){tX=1;}
  677.                                 int tY;
  678.                                 if(atoi(teilerY)>1)
  679.                                 {
  680.                                         tY=atoi(teilerY);
  681.                                 }
  682.                                 else
  683.                                 {
  684.                                         tY=tX;
  685.                                 }
  686.                                 int tZ;
  687.                                 if(atoi(teilerZ)>1)
  688.                                 {
  689.                                         tZ=atoi(teilerZ);
  690.                                 }
  691.                                 else
  692.                                 {
  693.                                         tZ=tX;
  694.                                 }
  695.  
  696.                                 if(tX>1||tY>1||tZ>1)
  697.                                 {
  698.                                         save<<sin(winkel*(Pi/180.0))*(urandom()%radX + atoi(radius_minX)) / (float)tX;
  699.                                         save<<" , "<<cos(winkel*(Pi/180.0))*(urandom()%radY + atoi(radius_minY)) / (float)tY;
  700.                                         if(radZ>0)
  701.                                         {
  702.                                                 save<<" , "<<(cos(winkelZ*(Pi/180.0))*sin(winkel*(Pi/180.0))*cos(winkel*(Pi/180.0)))*(urandom()%radZ + atoi(radius_minZ)) / (float)tZ;
  703.                                         }
  704.                                 }
  705.                                 else
  706.                                 {
  707.                                         save<<round(sin(winkel*(Pi/180.0))*(urandom()%radX + atoi(radius_minX)));
  708.                                         save<<" , "<<round(cos(winkel*(Pi/180.0))*(urandom()%radY + atoi(radius_minY)));
  709.                                         if(radZ>0)
  710.                                         {
  711.                                                 save<<" , "<<round((cos(winkelZ*(Pi/180.0))*sin(winkel*(Pi/180.0))*cos(winkel*(Pi/180.0)))*(urandom()%radZ + atoi(radius_minZ)));
  712.                                         }
  713.                                 }
  714.                         }
  715. */
  716.                         else if(Z==markerR[0])
  717.                         {
  718.                                 double winkel=(double)(rand()%36000000)/100000.0;
  719.                                 double winkelZ=(double)(rand()%36000000)/100000.0;
  720.  
  721.                                 int radX=atoi(radiusX)-atoi(radius_minX);
  722.                                 if(radX<1){radX=1;}
  723.                                 double rad_faktorY=1;
  724.                                 if(atoi(radiusY)>0)
  725.                                 {
  726.                                         rad_faktorY=(double)(radX/(atoi(radiusY)-atoi(radius_minY)));
  727.                                 }
  728.                                 double rad_faktorZ=1;
  729.                                 if(atoi(radiusZ)>0)
  730.                                 {
  731.                                         rad_faktorZ=(double)(radX/(atoi(radiusZ)-atoi(radius_minZ)));
  732.                                 }
  733.  
  734.                                 int tX=atoi(teilerX);
  735.                                 if(tX<1){tX=1;}
  736.                                 int tY;
  737.                                 if(atoi(teilerY)>1)
  738.                                 {
  739.                                         tY=atoi(teilerY);
  740.                                 }
  741.                                 else
  742.                                 {
  743.                                         tY=tX;
  744.                                 }
  745.                                 int tZ;
  746.                                 if(atoi(teilerZ)>1)
  747.                                 {
  748.                                         tZ=atoi(teilerZ);
  749.                                 }
  750.                                 else
  751.                                 {
  752.                                         tZ=tX;
  753.                                 }
  754.  
  755.                                 double radius=(rand()%radX + atoi(radius_minX));
  756.                                 if(tX>1||tY>1||tZ>1)
  757.                                 {
  758.                                         save<<(sin(winkel*(Pi/180.0)) * radius) / (double)tX;
  759.                                         save<<" , "<<((cos(winkel*(Pi/180.0))/rad_faktorY) * radius) / (double)tY;
  760.                                         if(rad_faktorZ!=1)
  761.                                         {
  762.                                                 save<<" , "<<(((cos(winkelZ*(Pi/180.0))/rad_faktorZ)*sin(winkel*(Pi/180.0))*(cos(winkel*(Pi/180.0))/rad_faktorY)) * radius) / (double)tZ;
  763.                                         }
  764.                                 }
  765.                                 else
  766.                                 {
  767.                                         save<<sin(winkel*(Pi/180.0)) * radius;
  768.                                         save<<" , "<<(cos(winkel*(Pi/180.0))/rad_faktorY) * radius;
  769.                                         if(rad_faktorZ!=1)
  770.                                         {
  771.                                                 save<<" , "<<((cos(winkelZ*(Pi/180.0))*sin(winkel*(Pi/180.0))*cos(winkel*(Pi/180.0)))/rad_faktorZ) * radius;
  772.                                         }
  773.                                 }
  774.                         }
  775.  
  776.                         else
  777.                         {
  778.                                 save<<Z;
  779.                         }
  780.                 }
  781.                 else
  782.                 {
  783. // nach stdout
  784.                         if(Z==marker1[0])
  785.                         {
  786.                                 if(atoi(teiler1)>1)
  787.                                 {
  788.                                         printf("%f",(float)(rand()%atoi(bereich1) + atoi(bereich2)) / atoi(teiler1));
  789.                                 }
  790.                                 else
  791.                                 {
  792.                                         printf("%i",rand()%atoi(bereich1) + atoi(bereich2));
  793.                                 }
  794.                         }
  795.                         else if(Z==marker2[0])
  796.                         {
  797.                                 if(atoi(teiler2)>1)
  798.                                 {
  799.                                         printf("%f",(float)(rand()%atoi(bereich3) + atoi(bereich4)) / atoi(teiler2));
  800.                                 }
  801.                                 else
  802.                                 {
  803.                                         printf("%i",rand()%atoi(bereich3) + atoi(bereich4));
  804.                                 }
  805.                         }
  806.                         else if(Z==marker3[0])
  807.                         {
  808.                                 if(atoi(teiler3)>1)
  809.                                 {
  810.                                         printf("%f",(float)(rand()%atoi(bereich5) + atoi(bereich6)) / atoi(teiler3));
  811.                                 }
  812.                                 else
  813.                                 {
  814.                                         printf("%i",rand()%atoi(bereich5) + atoi(bereich6));
  815.                                 }
  816.                         }
  817.                         else
  818.                         {
  819.                                 printf("%c",Z);
  820.                         }
  821.                 }
  822.         }
  823.  
  824.  
  825.  
  826.  
  827. // Fertig
  828.         load.close();
  829.         if(!stdout)
  830.         {
  831.                 save.close();
  832.         }
  833. }
  834.  
  835.  
  836.  
  837.  
  838.  
  839.  
  840.  
  841.  
  842.  
  843.  
  844.  
  845.  
  846.  
  847.  
  848.  
  849.  
  850.  
  851.  
  852. // Funktionen --------------------------------------------------------------------------------------
  853. void Bedienung()
  854. {
  855.         printf("\nz2z:                              Version %s\n------------------------------------------------\n",VERSION);
  856.         printf("Dieses Programm ersetzt alle gefundenen ""Marker-Zeichen"" durch Zufalls-Zahlen.\n");
  857.         printf("Man kann bis zu 3 Zeichen gleichzeitig ersetzen.\n\n");
  858.         printf("Die Marker (-m/-n/-o) duerfen dabei nur aus einem Zeichen bestehen.\n");
  859.         printf("  (Achten Sie darauf, dass die Marker in der Quelldatei nur an den Stellen\n");
  860.         printf("   vorkommen, die auch ersetzt werden sollen.)\n\n");
  861.         printf("Die Bereiche werden mit 1 oder 2 Werten angegeben (-1/-3/-5 und -2/-4/-6)\n");
  862.         printf("Sie koennen fuer fuer jeden Bereich auch einen Teiler (-t/-u/-v) angeben, um\n");
  863.         printf("Kommazahlen zu erzeugen.\n");
  864.         printf("Die Bedeutung der Werte ist:\n");
  865.         printf("  ( rand()%% wert1 + wert2 ) / teiler1\n");
  866.         printf("z.B.\n");
  867.         printf("  z2z -m [ -1 1000 -2 -500\n");
  868.         printf("  ersetzt alle >[< Zeichen durch Zufallszahlen im Bereich von -500 bis 499.\n");
  869.         printf("  z2z -m [ -1 1000 -2 -500 -t 10\n");
  870.         printf("  ersetzt alle >[< Zeichen durch Zufallszahlen im Bereich von -50.0 bis 49.9.\n\n");
  871.         printf("Der zweite Wert (-2/-4/-6) kann weggelassen werden.\n");
  872.         printf("z.B.\n");
  873.         printf("  z2z -m [ -1 1000\n");
  874.         printf("  ersetzt alle >[< Zeichen durch Zufallszahlen im Bereich von 0 bis 999.\n");
  875.         printf("  z2z -m [ -1 1000 -t 10\n");
  876.         printf("  ersetzt alle >[< Zeichen durch Zufallszahlen im Bereich von 0 bis 99.9.\n\n\n");
  877.         printf("Optionen:\n----------\n");
  878.         printf("-h | --help             | Diese Kurzhilfe\n");
  879.         printf("-q | --quelldatei NAME  | Quell-Dateiname\n");
  880.         printf("-z | --zieldatei NAME   | Ziel-Dateiname\n");
  881.         printf("                          (Wird der Ziel-Dateiname nicht angegeben,\n");
  882.         printf("                           wird auf stdout ausgegeben.)\n\n");
  883.         printf("-m | --marker1 ZEICHEN  | zu ersetzendes Zeichen1 (nur eines)\n");
  884.         printf("-1 | --bereich1 WERT    | Bereich1 der Zufallszahlen\n");
  885.         printf("-2 | --bereich2 WERT    | Bereich2 der Zufallszahlen\n");
  886.         printf("-t | --teiler1 WERT     | Teiler1 der Zufallszahlen\n\n");
  887.         printf("-n | --marker2 ZEICHEN  | zu ersetzendes Zeichen2 (nur eines)\n");
  888.         printf("-3 | --bereich3 WERT    | Bereich3 der Zufallszahlen\n");
  889.         printf("-4 | --bereich4 WERT    | Bereich4 der Zufallszahlen\n");
  890.         printf("-u | --teiler2 WERT     | Teiler2 der Zufallszahlen\n\n");
  891.         printf("-o | --marker3 ZEICHEN  | zu ersetzendes Zeichen3 (nur eines)\n");
  892.         printf("-5 | --bereich5 WERT    | Bereich5 der Zufallszahlen\n");
  893.         printf("-6 | --bereich6 WERT    | Bereich6 der Zufallszahlen\n");
  894.         printf("-v | --teiler3 WERT     | Teiler3 der Zufallszahlen\n\n");
  895.  
  896.         exit(1);
  897. }
  898.  
  899.  
  900.  
  901.  
  902.  
  903.  
  904.  
  905.  
  906. /*
  907. void urandom_init()
  908. {
  909.         urandom_fd = open("/dev/urandom", O_RDONLY);
  910.  
  911.         if (urandom_fd == -1)
  912.         {
  913.                 int errsv = urandom_fd;
  914.                 printf("Error opening [/dev/urandom]: %i\n", errsv);
  915.                 exit(1);
  916.         }
  917. }
  918.  
  919.  
  920.  
  921.  
  922.  
  923.  
  924.  
  925. unsigned long urandom()
  926. {
  927.         unsigned long buf_impl;
  928.         unsigned long *buf = &buf_impl;
  929.  
  930.         if(urandom_fd==-2)
  931.         {
  932.                 urandom_init();
  933.         }
  934.  
  935. // Read 4 bytes, or 32 bits into *buf, which points to buf_impl
  936.         read(urandom_fd, buf, sizeof(long));
  937.         return buf_impl;
  938. }
  939. */
  940.  
  941.  
  942.  
  943.  
  944.  
  945.  
  946. float MyRandom( float Bereich )
  947. {
  948.   float rNum = ( (float) rand() / (float) RAND_MAX ) * Bereich;
  949.   return rNum;
  950. }
  951.  
  952.  
  953.  
  954.  
  955.  
  956.  
  957.  
  958.  
  959. void test()
  960. {
  961. //      srandom(time(0));
  962.         for (int z=0;z<10000;z++)
  963.         {
  964.                 printf("%i\n",rand()%360);
  965. //              printf("%li\n",urandom()%360);
  966.         }
  967.         exit(0);
  968. }
  969.  
  970.  
  971.  
  972.  
  973.  
  974.  
  975.  
  976.  
  977.  
  978.  
  979.  
  980.  
  981.  
  982.  
  983.  
  984.  
  985.  
  986.  
  987.  
  988.  
  989.  
  990.  
  991.  
  992.  
  993.  
  994.  
  995.  
  996.  

Quellcode

Hier kannst du den Code kopieren und ihn in deinen bevorzugten Editor einfügen. Alternativ kannst du den gesamten Eintrag auch als Datei herunterladen.